1. '.' 默认匹配除 \n 之外的任意一个字符，若指定 flag DOTALL ,则匹配任意字符，包括换行
2. '^' 匹配字符开头，若指定 flags MULTILINE ,这种也可以匹配上( r "^a" , "\nabc\neee" , flags = re . MULTILINE )
3. '$' 匹配字符结尾，或 e . search ( "foo$" , "bfoo\nsdfsf" , flags = re . MULTILINE ). group ()也可以
4. '*' 匹配*号前的字符 0 次或多次， re . findall ( "ab*" , "cabb3abcbbac" ) 结果为[ 'abb' , 'ab' , 'a' ]
5. '+' 匹配前一个字符 1 次或多次， re . findall ( "ab+" , "ab+cd+abb+bba" ) 结果[ 'ab' , 'abb' ]
6. '?' 匹配前一个字符 1 次或 0 次
7. '{m}' 匹配前一个字符 m 次
8. '{n,m}' 匹配前一个字符 n 到 m 次， re . findall ( "ab{1,3}" , "abb abc abbcbbb" ) 结果 'abb' , 'ab' , 'abb' ]
9. '|' 匹配|左或|右的字符， re . search ( "abc|ABC" , "ABCBabcCD" ). group () 结果 'ABC'
10. '(...)' 分组匹配， re . search ( "(abc){2}a(123|456)c" , "abcabca456c" ). group () 结果 abcabca456c
13. '\A' 只从字符开头匹配， re . search ( "\Aabc" , "alexabc" ) 是匹配不到的
14. '\Z' 匹配字符结尾，同 $
15. '\d' 匹配数字 0 - 9
16. '\D' 匹配非数字
17. '\w' 匹配[ A - Za - z0 - 9 ]
18. '\W' 匹配非[ A - Za - z0 - 9 ]
19. 's' 匹配空白字符、 \t 、 \n 、 \r , re . search ( "\s+" , "ab\tc1\n3" ). group () 结果 '\t'
21. '(?P<name>...)' 分组匹配
22. re . search ( "(?P<province>[0-9]{4})(?P<city>[0-9]{2})(?P<birthday>[0-9]{4})" , "371481199306143242" ). groupdict ( "city" )
23. 结果{ 'province' : '3714' , 'city' : '81' , 'birthday' : '1993' }

1. re . I ( re . IGNORECASE ): 忽略大小写（括号内是完整写法，下同）
2. M ( MULTILINE ): 多行模式，改变 '^' 和 '$' 的行为
3. S ( DOTALL ): 点任意匹配模式，改变 '.' 的行为

正则表达式是一个特殊的字符序列，它能帮助你方便的检查一个字符串是否与某种模式匹配。

Python 自1.5版本起增加了re 模块，它提供 Perl 风格的正则表达式模式。

• re 模块-- 使 Python 语言拥有全部的正则表达式功能。
  
• compile 函数-- 根据 一个模式字符串 和 可选的标志参数 生成一个正则表达式对象。该对象拥有一系列方法用于正则表达式匹配和替换。
  
• re 模块-- 也提供了与这些方法功能完全一致的函数，这些函数使用一个模式字符串做为它们的第一个参数。
  

本文主要介绍Python中常用的正则表达式处理函数。

re.match函数

• re.match 尝试从字符串的开始匹配一个模式。
  
  • 函数语法 ：

1. re . match ( pattern , string , flags = 0 )

• • 函数参数说明：

  匹配对象方法	描述
  group(num=0)	匹配的整个表达式的字符串，group() 可以一次输入多个组号，在这种情况下它将返回 一个包含那些组所对应值的元组 。
  groups()	返回一个包含所有小组字符串的元组，从 1 到 所含的小组号。

  1. #!/usr/bin/python
  2. import re
  4. line = "Cats are smarter than dogs"
  6. matchObj = re . match ( r '(.*) are (.*?) .*' , line , re . M | re . I )
  8. if matchObj :
  9. print ( "matchObj.group() : " , matchObj . group ())
  10. print ( "matchObj.group(1) : " , matchObj . group ( 1 ))
  11. print ( "matchObj.group(2) : " , matchObj . group ( 2 ))
  12. else :
  13. print ( "No match!!" )
  1. #!/usr/bin/python
  2. import re
  4. line = "Cats are smarter than dogs"
  6. searchObj = re . search ( r '(.*) are (.*?) .*' , line , re . M | re . I )
  8. if searchObj :
  9. print ( "searchObj.group() : " , searchObj . group ())
  10. print ( "searchObj.group(1) : " , searchObj . group ( 1 ))
  11. print ( "searchObj.group(2) : " , searchObj . group ( 2 ))
  12. else :
  13. print ( "No search!!" )
• 以上实例执行结果如下：
  1. searchObj . group () : Cats are smarter than dogs
  2. searchObj . group ( 1 ) : Cats
  3. searchObj . group ( 2 ) : smarter

  re.match与re.search的区别

  • re.match只匹配字符串的开始 ，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；
  • 而re.search 匹配整个字符串 ，直到找到一个匹配。
    
    1. #!/usr/bin/python
    2. import re
    4. line = "Cats are smarter than dogs" ;
    6. matchObj = re . match ( r 'dogs' , line , re . M | re . I )
    7. if matchObj :
    8. print ( "match --> matchObj.group() : " , matchObj . group ())
    9. else :
    10. print ( "No match!!" )
    12. matchObj = re . search ( r 'dogs' , line , re . M | re . I )
    13. if matchObj :
    14. print ( "search --> matchObj.group() : " , matchObj . group ())
    15. else :
    16. print ( "No match!!" )
    • 以上实例运行结果如下：
      
    1. No match !!
    2. search --> matchObj . group () : dogs

    正则表达式模式

    • 模式字符串使用特殊的语法来表示一个正则表达式：
      
    • 字母和数字表示他们自身。一个正则表达式模式中的字母和数字匹配同样的字符串。
      
    • 多数字母和数字前加一个反斜杠时会拥有不同的含义。
      
    • 标点符号只有被转义时才匹配自身 ，否则它们表示特殊的含义。
      
    • 反斜杠本身需要使用反斜杠转义 。
      
    • 由于正则表达式通常都包含反斜杠，所以你最好使用原始字符串来表示它们。模式元素(如 r'/t'，等价于'//t')匹配相应的特殊字符。
      
    • 下表列出了正则表达式模式语法中的特殊元素。如果你使用模式的同时提供了可选的标志参数，某些模式元素的含义会改变。

    正则表达式的符号与方法

    1. 常用符号：点号，星号，问号与括号（小括号）
    3. . :匹配任意字符，换行符 \n 除外
    4. * :匹配前一个字符 0 次或无限次
    5. ? :匹配前一个字符 0 次或 1 次
    6. .* :贪心算法
    7. .*? :非贪心算法
    8. () :括号内的数据作为结果返回
    9. 常用方法： findall ， search ， sub
    11. findall ：匹配所有符合规律的内容，返回包含结果的列表
    12. search ：匹配并提取第一个规律的内容，返回一个正则表达式对象( object )
    13. sub ：替换符合规律的内容，返回替换后的值

    1. import re
    2. secret_code = 'ghkj08hs68xxIxxa14kgj4w314exxlovexxbvk14rgjhxxyouxxfj4286ykjhag2'
    3. b = re . findall ( 'xx.*xx' , secret_code )
    4. print ( b )

    1. import re
    2. secret_code = 'ghkj08hs68xxIxxa14kgj4w314exxlovexxbvk14rgjhxxyouxxfj4286ykjhag2'
    3. b = re . findall ( 'xx.*?xx' , secret_code )
    4. print ( b )

    1. import re
    2. secret_code = 'ghkj08hs68xxIxxa14kgj4w314exxlovexxbvk14rgjhxxyouxxfj4286ykjhag2'
    3. b = re . findall ( 'xx(.*?)xx' , secret_code )
    4. print ( b )

    1. [ 'I' , 'love' , 'you' ]

    1. import re
    2. secret_code = '''ghkj08hs68xxIxxa14kgj4w314exxlove
    3. xxbvk14rgjhxxyouxxfj4286ykjhag2'''
    4. #love后有换行符
    5. b = re . findall ( 'xx(.*?)xx' , secret_code )
    6. print ( b )
    7. # 因为.不能匹配换行符。所以会一行为一个搜索项去找。匹配任何字符除了新的一行

    1. import re
    2. secret_code = '''ghkj08hs68xxIxxa14kgj4w314exxlove
    3. xxbvk14rgjhxxyouxxfj4286ykjhag2'''
    4. #love后有换行符
    5. b = re . findall ( 'xx(.*?)xx' , secret_code , re . S )
    6. print ( b )
    7. # re.S让.匹配所有行，包括了换行符（以\n的形式出现）

    1. import re
    2. s2 = '''ghkj08hs68xxIxx123xxlove
    3. xxbvk14rgjhxxfj4286ykjhag2'''
    4. b = re . search ( 'xx(.*?)xx(.*?)xx' , s2 , re . S ). group ( 1 )
    5. print ( b )
    6. c = re . search ( 'xx(.*?)xx(.*?)xx' , s2 , re . S ). group ( 2 )
    7. print ( c )
    8. d = re . search ( 'xx(.*?)xx(.*?)xx' , s2 , re . S ). group ( 3 )
    9. print ( d )

    1. import re
    2. s2 = '''ghkj08hs68xxIxx123xxlovexxbvk14rgjhxxfj4286ykjhag2'''
    3. f2 = re . findall ( 'xx(.*?)xx123xx(.*?)xx' , s2 , re . S )
    4. print ( f2 )
    5. print ( f2 [ 0 ][ 1 ])

    1. re . sub ( pattern , repl , string , count = 0 , flags = 0 )
    3. 找到 RE 匹配的所有子串，并将其用一个不同的字符串替换。
    5. 1. 第一个参数： pattern
       2. pattern ，表示正则中的模式字符串
       4. 第二个参数： repl
       5. repl ，就是 replacement ，被替换，的字符串的意思。
       7. 第三个参数： string
       8. string ，即表示要被处理，要被替换的那个 string 字符串。
       11. 第四个参数：可选参数 count 是模式匹配後替换的最大次数； count 必须是非负整数。
       12. 缺省值是 0 表示替换所有的匹配。如果无匹配，字符串将会无改变地返回。
    7. re . subn ( pattern , repl , string , count = 0 , flags = 0 )
    8. 与 re . sub 方法作用一样，但返回的是包含新字符串和替换执行次数的两元组。
    9. 


    1. import re
    2. s = '123abcssfasdfas123'
    3. output = re . sub ( '123(.*?)123' , '123789123' , s )
    4. print ( output )
    5. # sub将符合条件的()内内容提换

    1. import re
    2. inputStr = "hello 123 world 456"
    3. replacedStr = re . sub ( "\d+" , "222" , inputStr )
    4. print ( replacedStr )

    1. import re
    2. secret_code = '''ghkj08hs68xxIxxa14kgj4w314exxlove
    3. xxbvk14rgjhxxyouxxfj4286ykjhag2'''
    4. pattern = 'xx(.*?)xx'
    5. new_pattern = re . compile ( pattern , re . S )
    6. b = re . findall ( new_pattern , secret_code )
    7. print ( b )

    1. import re
    2. a = 'dfhkgh43gfhja873y5t2167715'
    3. b = re . findall ( '(\d+)' , a )
    4. print ( b )

    1. < html >
    2. < head >
    3. < title >极客学院爬虫测试</ title >
    4. </ head >
    5. < body >
    6. < div class = "topic" >< a href = "http://jikexueyuan.com/welcome.html" >欢迎参加《 Python 定向爬虫入门》</ a >
    7. < div class = "list" >
    8. < ul >
    9. < li >< a href = "http://jikexueyuan.com/1.html" >这是第一条</ a ></ li >
    10. < li >< a href = "http://jikexueyuan.com/2.html" >这是第二条</ a ></ li >
    11. < li >< a href = "http://jikexueyuan.com/3.html" >这是第三条</ a ></ li >
    12. </ ul >
    13. </ div >
    14. </ div >
    15. </ body >
    16. </ html >

    1. for i in range ( 2 , total_page + 1 ):
    2. new_link = re . sub ( 'pageNum=\d+' , 'pageNum=%d' % i , old_url , re . S )
    3. print new_link

    1. import re
    2. a = 'xzx23'
    4. # . :匹配任意字符，换行符\n除外
    5. # 点.是一个占位符，一个.代表一个符号
    6. b = re . findall ( 'x.' , a )
    7. print ( ". :匹配任意字符，换行符\\n除外:" , b )
    9. # * :匹配前一个字符0次或无限次
    10. # 依次匹配字符，有则显示，无则显示''(空)。
    11. c = re . findall ( 'x*' , a )
    12. print ( "* :匹配前一个字符0次或无限次:" , c )
    14. # 问号?
    15. # ? :匹配前一个字符0次或1次
    16. # 单独与*一样，前面附加其他的符号将做非贪心限制
    17. d = re . findall ( 'x?' , a )
    18. print ( "? :匹配前一个字符0次或1次:" , d )
    20. # 贪心.*
    21. # 只要满足条件全部显示，贪心算法
    22. secret_code = 'ghkj08hs68xxIxxa14kgj4w314exxlovexxbvk14rgjhxxyouxxfj4286ykjhag2'
    23. e = re . findall ( 'xx.*xx' , secret_code )
    24. print ( "贪心.*:" , e )
    26. # 非贪心.*?
    27. secret_code = 'ghkj08hs68xxIxxa14kgj4w314exxlovexxbvk14rgjhxxyouxxfj4286ykjhag2'
    28. f = re . findall ( 'xx.*?xx' , secret_code )
    29. print ( "非贪心.*?:" , f )
    31. # () :括号内的数据作为结果返回
    32. # ()包围所需要的内容，括号内的内容作为结果返回，不需要的内容放在括号外面
    33. secret_code = 'ghkj08hs68xxIxxa14kgj4w314exxlovexxbvk14rgjhxxyouxxfj4286ykjhag2'
    34. g = re . findall ( 'xx(.*?)xx' , secret_code )
    35. print ( "非贪心.*?:" , g )
    39. # sub将符合条件的()内内容提换
    40. # sub：替换符合规律的内容，返回替换后的值
    41. s = '123abcssfasdfas123'
    42. output = re . sub ( '123(.*?)123' , '123789123' , s )
    43. print ( 'sub将符合条件的()内内容提换:' , output )
    47. # re.S让.匹配所有行，包括了换行符（以\n的形式出现）
    49. # search 找到一个后返回，不继续，大大提高效率
    50. # findall遍历全部，找到尽可能多的项
    51. s2 = '''ghkj08hs68xxIxx123xxlove
    52. xxbvk14rgjhxxfj4286ykjhag2'''
    53. b = re . search ( 'xx(.*?)xx(.*?)xx' , s2 , re . S )
    54. print ( 'search 找到一个后返回，不继续，大大提高效率:' , b )
    55. # 输出
    56. # < _sre.SRE_Match
    57. # object;
    58. # span = (10, 20), match = 'xxIxx123xx' >
    60. # group是按括号顺序匹配
    61. b = re . search ( 'xx(.*?)xx(.*?)xx' , s2 , re . S ). group ( 1 )
    62. print ( 'search 找到一个后返回，不继续，大大提高效率:' , b )
    63. # .group(3)报错
    64. # Traceback (most recent call last):
    65. # File "D:/WorkSpace/python/PycharmProjects/爬虫/代码/Python-master/ReDemo.py", line 61, in <module>
    66. # b = re.search('xx(.*?)xx(.*?)xx', s2, re.S).group(3)
    67. # IndexError: no such group
    69. # 每一个匹配项为第一级列表，括号为二级列表
    70. s2 = '''ghkj08hs68xxIxx123xxlovexxbvk14rgjhxxfj4286ykjhag2'''
    71. f2 = re . findall ( 'xx(.*?)xx123xx(.*?)xx' , s2 , re . S )
    72. print ( '每一个匹配项为第一级列表，括号为二级列表:' , f2 [ 0 ][ 1 ])

    总结--常用正则表达式符号'.' 默认匹配除\n之外的任意一个字符，若指定flag DOTALL,则匹配任意字符，包括换行'^' 匹配字符开头，若指定flags MULTILINE,这种也可以匹配上(r"^a","\nabc\neee",flags=re.MULTILINE)'$' 匹配字符结尾，或e.search("foo$","bfoo\n

    垃圾邮件分类（trec06c数据集）数据处理-1 目标：我要提取 发件人（From）、收件人(To)、邮件主题(Subject)、邮件正文(zhengwen) 作为邮件特征，然后输入到线性分类模型中进行训练 首先是这四个特征提取的部分 获取 标签--路径 对照表 把这一部分的全部的代码放这儿： ~~~~~~~~~~~待更新~~~~~~~~~~~~~~~~~~~~~~~~~~~ re.compile(r'<[^>]+>',re.S), re.compile(r'\&[a-zA-Z]+;',re.S), re.compile(r'\n|\t',re.S), re.compile(r'\[|\]|\(|\)',re.S), # r...

    正则表达式 是一个特殊的字符序列，检查一个字符串是否与某种模式匹配。 Python 自1.5版本起，增加re模块，提供Perl风格的 正则表达式 模式。re模块使 Python 语言拥有全部的 正则表达式 功能。 compile函数根据一个模式字符串和可选的标志参数生成一个 正则表达式 对象。该对象拥有一系列方法用于 正则表达式 匹配和替换。 re模块也提供与这些方法功能完全一致的函数，这些函数使用一个模式字符串做

    什么是正则？ 正则就是用一些具有特殊含义的符号组合到一起（ 正则表达式 ）来描述字符或者字符串的方法。或者说：正则就是用来描述一类事物的规则。内嵌在 Python 中，通过re模块实现。 正则表达式 模式被编译成一系列的字节码，然后由用c编写的匹配引擎执行。 常用 正则表达式 符号 '.' 默认匹配除\n之外的任意一个字符，若指定flag DOTALL,则匹配任意字符，包括换行 text = 'Jame 12 years old' pattern = r'[A-Z]\w+\s\d{1,2}' # 正则，匹配出名字和年龄 result = re.sub(pattern,'hello',text) # 将匹配出的内容替换为hello print(text) #打印原来的文本 print(resul... 泰坦尼克号生存预测是kaggle上面对于初级机器学习者比较适合的用来练习的比赛，本人现在想学习一些特征工程之类相关的只是，所以就是看了一下kaggle上面的大佬展示出来的notebook，有些理解与你们共享，互相学习 数据集说明 首先我们在学习之前要来看一下就是这个我们要学习的数据集，对于这个数据，然后来看作者是要进行怎样的操作，他是怎么操作 ，学习一下思路