017-Python正则表达式

1. 正则表达式的概念

• 正则表达式，又称规则表达式。
• 英文单词（Regular Expression，在代码中常简写为rege,regexp或re）
• 正则表达式通常用来检索、替换那些符合某个模式（规则）的文本内容
• 正则表达式是一种文本模式，模式描述在搜索文本时要匹配的一个或多个字符串

2. 正则模块——re模块

• 在python语言中，可用re模块来完成字符串的正则匹配

2.1 re.match(pattern， string， flags=0)

• 第一个参数pattern是正则表达式
• 第二个参数string是需要匹配的字符串
• 第三个参数flags是标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等
  • re.I，I是IGNORECASE的简写，执行不区分大小写的匹配 ；如[A-Z]表达式将太匹配小写字母。这不被受当前的区域设置。
  • re.S，S是DOTALL的简写，使’.'特殊字符匹配任何字符，包括换行 ；如果没有此标志， '.'将匹配任何内容除换行符
  • re.X，X是VERBOSE的简写，此标志允许您编写正则表达式，看起来更好。在模式中的空白将被忽略，除非当在字符类或者前面非转义反斜杠，和，当一条线包含一个’#‘既不在字符类中或由非转义反斜杠，从最左侧的所有字符之前，这种’#'通过行末尾将被忽略。
  • re.U，U是UNICODE的简写，使得\w, \W, \b, \B, \d, \D, \s和 \S 取决于UNICODE定义的字符属性
  • re.M，M是MULTILINE的简写，当指定时，模式字符’ ^‘匹配字符串的开头以及每个行的开头（紧接每个换行符）； 模式字符’KaTeX parse error: Expected group after '^' at position 38: …换行符之前）。默认情况下， '^̲'只匹配字符串的开始，''只匹配字符串的末尾和字符串末尾换行符（如果有的话）之前的位置
  • re.L，L是LOCALE的简写，使得\w,\W,\b,\B,\s和\S在当前文件生效
  • re. DEBUG，显示调试信息编译的表达式
• 这个模块的方法只能匹配，以正则表达式内容作为字符串开头的内容
• 匹配不成功返回None，匹配成功返回match对象，使用对象.group获取匹配成功的字符串
  • 对象.group获取符合匹配的元组

import re  # 导入re模块

# 需要匹配的字符串
string = 'hello world'

# 正则表达式
pattern = 'h'

# 匹配
result = re.match(pattern, string)

# 打印匹配大的内容
print(result.group())

D:\python\python.exe D:/project/index.py
h

Process finished with exit code 0

3. 正则表达式的组成部分

原子符：
    1、普通字符或者是单字符，0-9，a-z,A-Z
    2、在正则中具有一些特殊意义的字符，需要转义  比如： \* \' \. \" \?

    3、通配类型
        \d:匹配的是十进制的数字0-9
        \D:匹配除了十进制的以外的字符

        \s：匹配空白字符 \n \t \r \f
        \S:匹配除空白字符以外的

        \w:匹配任意数字，字母，下划线
        \W:匹配除了任意数字，字母，下划线

    4、原子表
        将多个原子组合一起使用
        [0-9a-zA-Z]:中的都是普通的原子
        []:组合多个原子
        [abc]:表示只匹配其中一个例如：a,b,c。不可以匹配ab bc abc
        [^abc]:匹配除了  abc  以外字符  a,b,c,ab,ac,bc
        [abc]09:匹配a09 b09 c09
        [aaa]
        [aa]
元字符：
    对原子符的修饰，不可以单独出现，必须配合原子符
	
    1、限定符
        表示原子出现多少次
        *:表示     前面的原子    可以出现 0次 1次 多次
        +:表示     前面的原子    出现1次 多次
        ?:表示     前面的原子    出现0次 1次
        {n}:表示   前面的原子    恰好出现 n次
        {n,}:表示  前面的原子    至少出现n次
        {n,m}:表示 前面的原子    ，至少出现n次，最多出现m次

    2、边界限定
        ^:必须以 ^ 后面字符开头
        $:必须以 $ 前面的字符结尾
        \b:词边界
        \B:非词边界
        'ru lai fo zu'
            :ru 右词边界, lai 两边都有词边界, zu有左词边界
    3、点
        . :表示可以匹配所有的字符
    4、模式单元  ()  0-9 a-z A-Z
        ():将几个原子组成一个大原子使用
        (abc): abc
        (123):123				
        使用模式单元匹配到的内容，会将匹配的临时存储在缓存区，可以再一次使用缓存区的内容，这种使用方式：后向引用				
    5、模式选择符
     |:表示多选一
     abc|cba :可以匹配abc 也可以匹配cba
     mysql|linux|php|apache
模式修饰符
    对正则表达式进行一些修饰
    .* :贪婪模式
    'aghdfghsdfg'
    'a.*g':将整个字符串全部匹配到
    'a(.*?)g'：取消贪婪模式

4. 原生字符串

• python语言中， \表示转义，字符串中的\n代表换行，字符串中的\t代表制表符，字符串中的\\代表\本身

  # string = 'D:\project\test.txt' \是有特殊意义，要表达\，则要\\转义
  string = 'D:\\project\\test.txt'
  print(string)
  

  D:\python\python.exe D:/project/index.py
  D:\project\test.txt
  
  Process finished with exit code 0
  

• python语言中，可以在字符串前面加r或R，表示字符串最后需要表达的就是那个内容，那么字符串里特殊的字符就不会发生转义了

  string = r'D:\project\test.txt'
  print(string)
  

  D:\python\python.exe D:/project/index.py
  D:\project\test.txt
  
  Process finished with exit code 0
  

• 正则表达式中的\也有特殊的意义，如果想表达\本身，那么也需要转义\\

  # 1.引进正则模块
  import re
  
  # 2.需要正则的字符串
  string = r'D:\project\test.txt'
  
  # 3.正则表达式
  # 正则表达式\\才代表\本身
  pattern = r'D:\\project\\test'
  
  # 匹配
  result = re.match(pattern, string).group()
  print(result)
  

  D:\python\python.exe D:/project/index.py
  D:\project\test
  
  Process finished with exit code 0
  

5. 分组匹配

• |匹配左右任意一个表达式
• (ab)是一个模式单元，是一个整体。使用模式单元匹配到的内容，会将匹配的临时存储在缓存区，可以再一次使用缓存区的内容，这种使用方式：后向引用
• 为了防止模式单元过多造成后向引用使用混乱，可以给模式单元取别名
  • 用(?P<name>模式单元内容)给模式单元起别名， (?P=name)后向引用模式单元

    pattern = r'<([a-zA-Z]*)>.*</\1>'
    
    pattern = r'<(?P<name1>[a-zA-Z]*)>.*</?P=name1>'
    

1） 案例1：匹配一或两位字符串格式的十进制数字

In [1]: import re
# 正则表达式能匹配一位或者两位十进制字符串格式的数字
In [2]: ret = re.match('[1-9]?\d', '8')

In [3]: ret.group()
Out[3]: '8'

2） 案例2：匹配一或两位字符串数字或者字符串数字100

In [1]: import re

# | 匹配左右任意一个表达式
In [2]: ret = re.match('[1-9]?\d$|100', '100')

In [3]: ret.group()
Out[3]: '100'

3） 案例3：匹配一个标签格式的字符串，标签里的内容任意

In [1]: import re

In [2]: ret = re.match('<[a-zA-Z]*>.*</[a-zA-Z]*>' ,'<div>hello world</div>')

In [3]: ret.group()
Out[3]: '<div>hello world</div>'

4） 应用模式单元的后向引用，改进案例3

In [1]: import re

In [2]: ret = re.match(r'<([a-zA-Z]*)>.*</\1>' ,'<div>hello world</div>')

In [3]: ret.group()
Out[3]: '<div>hello world</div>'

5） 案例4：模式单元取别名

In [1]: import re

In [2]: ret = re.match(r'<(?P<name1>[a-zA-Z]*)>.*</(?P=name1)>' ,'<div>hello wo
   ...: rld</div>')

In [3]: ret.group()
Out[3]: '<div>hello world</div>'

6. re模块高级方法

• compile将正则表达式模式编译成一个正则表达式对象，reg = re.compile(pattern) 重用效率更高

  • reg.match(string)用法

    reg = re.compile(pattern)
    result = reg.match(string)
    
    # 等价于
    result = re.match(pattern, string)
    

  • reg.search(string)用法

    reg = re.compile(pattern)
    result = reg.search(string)
    
    # 等价于
    result = re.search(pattern, string)
    

  • reg.findall(string)用法

    reg = re.compile(pattern)
    result = reg.findall(string)
    
    # 等价于
    result = re.findall(pattern, string)
    

• re.sub(pattern, repl, string, count=0, flags=0)用法

  • pattern正则表达式
  • repl替换后的字符串
  • count()参数替换个数。默认为0，表示每个匹配项都替换

In [1]: import re

In [2]: re.sub('world', 'rulai', 'hello world')
Out[2]: 'hello rulai'

• re.split(pattern, string, maxsplit=0, flags=0)用法
  • pattern正则表达式
  • maxsplit分割的次数。默认为0，表示符合条件都分割

In [1]: import re

In [2]: re.split(',', '1,2,3,4')
Out[2]: ['1', '2', '3', '4']