日本免费高清视频-国产福利视频导航-黄色在线播放国产-天天操天天操天天操天天操|www.shdianci.com

學無先后，達者為師

網站首頁 編程語言 正文

Python中的re正則表達式模塊_python

作者：springsnow ? 更新時間： 2022-07-27 編程語言

一、re模塊的基本使用

Python里數量詞默認是貪婪的，總是嘗試匹配盡可能多的字符。正則表達式是用來匹配處理字符串的。

假如你需要匹配文本中的字符\，Python里的使用原生字符串表示：r'\\'表示。同樣，匹配一個數字的\\d可以寫成r'\d'。

1、python 中使用正則表達式需要引入re模塊

import re  # 第一步，要引入re模塊
a = re.findall("匹配規則", "這個字符串是否有匹配規則的字符")  # 第二步，調用模塊函數
print(a)  # 以列表形式返回匹配到的字符串
# ['匹配規則']

2、常見元字符

  • ^元字符:匹配字符串開頭。
  • $元字符:匹配字符串末尾。
  • *元字符:匹配前一個字符0或多次
  • +元字符:匹配前一個字符1次或無限次
  • ?元字符(防止貪婪匹配):匹配一個字符0次或1次:還有一個功能是在量詞后面加上？號防止貪婪匹配 。
  • {}元字符(范圍):自定義字符數{m}匹配前一個字符m次，
    {m,n}匹配前一個字符m至n次，若省略n，則匹配m至無限次
    {0,}匹配前一個字符0或多次,等同于*元字符
    {+,}匹配前一個字符1次或無限次,等同于+元字符
    {0,1}匹配前一個字符0次或1次,等同于?元字符
  • []元字符(字符集):[]里的任意一個字符就匹配字符集。字符集中的字符可以逐個列出，也可以給出范圍，如[abc]或[a-c]。[^abc]表示取反，即非abc。
    所有特殊字符在字符集中都失去其原有的特殊含義。用\反斜杠轉義恢復特殊字符的特殊含義。
  • [^]:反取，匹配出除[^]里面的字符。
    ^元字符如果寫到字符集里就是反取
  • \d:匹配任何十進制數，它相當于類[0-9]
  • \D:匹配任何非數字字符，它相當于類[^0-9]
  • \s:匹配任何空白字符，它相當于類[\t\n\r\f\v]
  • \S:匹配任何非空白字符，它相當于類[^\t\n\r\f\v]
  • \w:匹配包括下劃線在內任何字母數字字符，它相當于類[a-zA-Z0-9_]
  • \W:匹配非任何字母數字字符包括下劃線在內，它相當于類[^a-zA-Z0-9_]
  • ()元字符(分組):分組匹配。()里面的為一個組也可以理解成一個整體。
    如果()后面跟的是特殊元字符如 (adc)* 那么*控制的前導字符就是()里的整體內容，不再是前導一個字符。
  • |元字符(或):就是前后其中一個符合就匹配

二、re模塊中常用功能函數

1、 正則表達式的兩種書寫方式

1、一種是直接在函數里書寫規則，推薦使用

import re

a = re.findall("匹配規則", "這個字符串是否有匹配規則的字符")
print(a)  # ['匹配規則']

2、另一種是先將正則表達式的字符串形式編譯為Pattern實例，然后使用Pattern實例處理文本并獲得匹配結果（一個Match實例），最后使用Match實例獲得信息，進行其他的操作。

re.compile(pattern[, flag])函數：用于將字符串形式的正則表達式編譯為Pattern對象

這個方法是Pattern類的工廠方法。 第二個參數flag是匹配模式，取值可以使用按位或運算符'|'表示同時生效，比如re.I | re.M。

另外，你也可以直接在pattern字符串中指定模式，比如re.compile('pattern', re.I | re.M)與re.compile('(?im)pattern')是等價的。

import re

# 將正則表達式編譯成Pattern對象
pattern = re.compile(r'hello')

# 使用Pattern匹配文本，獲得匹配結果，無法匹配時將返回None
match = pattern.match('hello world!')

if match:
    # 使用Match獲得分組信息
    print(match.group())  # hello

2、匹配模式

下表是所有的正則匹配模式：

  • re.I：使匹配對大小寫不敏感
  • re.L：做本地化識別（locale-aware）匹配
  • re.M：多行匹配，影響 ^ 和 $
  • re.S：使 . 匹配包括換行在內的所有字符
  • re.U：根據Unicode字符集解析字符。這個標志影響 \w, \W, \b, \B.
  • re.X：該標志通過給予你更靈活的格式以便你將正則表達式寫得更易于理解。

1、 re.S：擴展

在Python的正則表達式中，有一個參數為re.S。它表示 “.” 的作用擴展到整個字符串，包括“\n”。看如下代碼：

import re

a = '''asdfhellopass:
    worldaf
    '''
b = re.findall('hello(.*?)world', a)
c = re.findall('hello(.*?)world', a, re.S)
print('b is ', b)  # b is  []
print('c is ', c)  # c is  ['pass:\n    ']

正則表達式中，“.”的作用是匹配除“\n”以外的任何字符，也就是說，它是在一行中進行匹配。這里的“行”是以“\n”進行區分的。a字符串有每行的末尾有一個“\n”，不過它不可見。

如果不使用re.S參數，則只在每一行內進行匹配，如果一行沒有，就換下一行重新開始，不會跨行。而使用re.S參數以后，正則表達式會將這個字符串作為一個整體，將“\n”當做一個普通的字符加入到這個字符串中，在整體中進行匹配。

2、 re.I：不區分大小寫

import re

res = re.findall(r"A", "abc", re.I)
print(res)# ['a']

3、 分組函數

?P?：（只對正則函數返回對象時有用）# ?P<>定義組里匹配內容的key(鍵)，<>里面寫key名稱，值就是匹配到的內容

取出匹配對象三種方法：（只對正則函數返回對象的有用）

  • group() # 獲取匹配到的所有結果，不管有沒有分組將匹配到的全部拿出來，有參取匹配到的第幾個如2
  • groups() # 獲取模型中匹配到的分組結果，只拿出匹配到的字符串中分組部分的結果
  • groupdict() # 獲取模型中匹配到的分組結果，只拿出匹配到的字符串中分組部分定義了key的組結果

3、re.match(常用)：從頭匹配一個符合規則的字符串，從起始位置開始匹配，匹配成功返回一個對象，未匹配成功返回None

match(pattern, string, flags=0)

  • pattern： 正則模型
  • string ： 要匹配的字符串
  • falgs ： 匹配模式

注意：match()函數 與 search()函數基本是一樣的功能，不一樣的就是match()匹配字符串開始位置的一個符合規則的字符串，search()是在字符串全局匹配第一個符合規則的字符串

import re

# 無分組
origin = "hello egon bcd egon lge egon acd 19"
r = re.match("h\w+", origin)  # match，從起始位置開始匹配，匹配成功返回一個對象，未匹配成功返回None
print(r.group())  # 獲取匹配到的所有結果，不管有沒有分組將匹配到的全部拿出來
print(r.groups())  # 獲取模型中匹配到的分組結果，只拿出匹配到的字符串中分組部分的結果
print(r.groupdict())  # 獲取模型中匹配到的分組結果，只拿出匹配到的字符串中分組部分定義了key的組結果
# hello
# ()
# {}

# 有分組
# 為何要有分組？提取匹配成功的指定內容（先匹配成功全部正則，再匹配成功的局部內容提取出來）
r = re.match("h(\w+)", origin)  # match，從起始位置開始匹配，匹配成功返回一個對象，未匹配成功返回None
print(r.group())  # 獲取匹配到的所有結果，不管有沒有分組將匹配到的全部拿出來
print(r.groups())  # 獲取模型中匹配到的分組結果，只拿出匹配到的字符串中分組部分的結果
print(r.groupdict())  # 獲取模型中匹配到的分組結果，只拿出匹配到的字符串中分組部分定義了key的組結果
# hello
# ('ello',)
# {}

# 有兩個分組定義了key
# 為何要有分組？提取匹配成功的指定內容（先匹配成功全部正則，再匹配成功的局部內容提取出來）
# ?P<>定義組里匹配內容的key(鍵)，<>里面寫key名稱，值就是匹配到的內容
r = re.match("(?Ph)(?P\w+)", origin)
print(r.group())  # 獲取匹配到的所有結果，不管有沒有分組將匹配到的全部拿出來
print(r.groups())  # 獲取模型中匹配到的分組結果，只拿出匹配到的字符串中分組部分的結果
print(r.groupdict())  # 獲取模型中匹配到的分組結果，只拿出匹配到的字符串中分組部分定義了key的組結果
# hello
# ('h', 'ello')
# {'n1': 'h', 'n2': 'ello'}

4、 re.search(pattern, string[, flags])：瀏覽整個字符串去匹配第一個符合規則的字符串，未匹配成功返回None

search(pattern, string, flags=0)

  • pattern： 正則模型
  • string ： 要匹配的字符串
  • falgs ： 匹配模式

注意：match()函數 與 search()函數基本是一樣的功能，不一樣的就是match()匹配字符串開始位置的一個符合規則的字符串，search()是在字符串全局匹配第一個符合規則的字符串

import re

# 無分組
origin = "hello alex bcd alex lge alex acd 19"
# search瀏覽全部字符串，匹配第一符合規則的字符串，瀏覽整個字符串去匹配第一個，未匹配成功返回None
r = re.search("a\w+", origin)
print(r.group() )  # 獲取匹配到的所有結果，不管有沒有分組將匹配到的全部拿出來
print(r.groups() )  # 獲取模型中匹配到的分組結果，只拿出匹配到的字符串中分組部分的結果
print(r.groupdict() )  # 獲取模型中匹配到的分組結果，只拿出匹配到的字符串中分組部分定義了key的組結果
# alex
# ()
# {}

# 有分組
# 為何要有分組？提取匹配成功的指定內容（先匹配成功全部正則，再匹配成功的局部內容提取出來）
r = re.search("a(\w+).*(\d)", origin)
print(r.group())  # 獲取匹配到的所有結果，不管有沒有分組將匹配到的全部拿出來
print(r.groups())  # 獲取模型中匹配到的分組結果，只拿出匹配到的字符串中分組部分的結果
print(r.groupdict())  # 獲取模型中匹配到的分組結果，只拿出匹配到的字符串中分組部分定義了key的組結果
# alex bcd alex lge alex acd 19
# ('lex', '9')
# {}

# 有兩個分組定義了key
# 為何要有分組？提取匹配成功的指定內容（先匹配成功全部正則，再匹配成功的局部內容提取出來）
# ?P<>定義組里匹配內容的key(鍵)，<>里面寫key名稱，值就是匹配到的內容
r = re.search("a(?P\w+).*(?P\d)", origin)
print(r.group())  # 獲取匹配到的所有結果，不管有沒有分組將匹配到的全部拿出來
print(r.groups())  # 獲取模型中匹配到的分組結果，只拿出匹配到的字符串中分組部分的結果
print(r.groupdict())  # 獲取模型中匹配到的分組結果，只拿出匹配到的字符串中分組部分定義了key的組結果
# alex bcd alex lge alex acd 19
# ('lex', '9')
# {'n1': 'lex', 'n2': '9'}

5、 re.findall()(常用)：瀏覽全部字符串，匹配所有合規則的字符串，匹配到的字符串放到一個列表中，未匹配成功返回空列表

findall(pattern, string, flags=0)

  • pattern： 正則模型
  • string ： 要匹配的字符串
  • falgs ： 匹配模式

注意：一旦匹配成，再次匹配，是從前一次匹配成功的，后面一位開始的，也可以理解為匹配成功的字符串，不在參與下次匹配。

1、無分組：匹配所有合規則的字符串，匹配到的字符串放到一個列表中

import re
# 無分組
r = re.findall("\d+\w\d+", "a2b3c4d5")  # 瀏覽全部字符串，匹配所有合規則的字符串，匹配到的字符串放到一個列表中
print(r)  # 注意：匹配成功的字符串，不在參與下次匹配,所以3c4也符合規則但是沒匹配到
# ['2b3', '4d5']

注意：如果沒寫匹配規則，也就是空規則，返回的是一個比原始字符串多一位的，空字符串列表

import re
# 無分組
r = re.findall("", "a2b3c4d5")  # 瀏覽全部字符串，匹配所有合規則的字符串，匹配到的字符串放到一個列表中
print(r)  # 注意：如果沒寫匹配規則，也就是空規則，返回的是一個比原始字符串多一位的，空字符串列表
# ['', '', '', '', '', '', '', '', '']

2、有分組：只將匹配到的字符串里組的部分放到列表里返回，相當于groups()方法

import re
origin = "hello alex bcd alex lge alex acd 19"
r = re.findall("a(\w+)", origin)  # 有分組：只將匹配到的字符串里，組的部分放到列表里返回
print(r)
# ['lex', 'lex', 'lex', 'cd']

注意：如果規則里只有一個組，而組后面是就表示組里的內容可以是0個或者多個，這樣組里就有了兩個意思，一個意思是匹配組里的內容，二個意思是匹配組里0內容（即是空白），所以盡量避免使用，否則會有可能匹配出空字符串

import re
origin = "hello alex bcd alex lge alex acd 19"
r = re.findall("(a)*", origin)
print(r)
# ['', '', '', '', '', '', 'a', '', '', '', '', '', '', '', '', 'a', '', '', '', '', '', '', '', '', 'a', '', '', '', '', 'a', '', '', '', '', '', '']

3、多個分組：只將匹配到的字符串里組的部分放到一個元組中，最后將所有元組放到一個列表里返回。

相當于在group()結果里再將組的部分，分別拿出來放入一個元組，最后將所有元組放入一個列表返回

import re
origin = "hello alex bcd alex lge alex acd 19"
# 多個分組：只將匹配到的字符串里，組的部分放到一個元組中，最后將所有元組放到一個列表里返回
r = re.findall("(a)(\w+)", origin)
print(r)
# [('a', 'lex'), ('a', 'lex'), ('a', 'lex'), ('a', 'cd')]

4、分組中有分組：只將匹配到的字符串里組的部分放到一個元組中，先將包含有組的組，看作一個整體也就是一個組，把這個整體組放入一個元組里，然后在把組里的組放入一個元組，最后將所有組放入一個列表返回

import re
origin = "hello alex bcd alex lge alex acd 19"
# 分組中有分組：只將匹配到的字符串里，組的部分放到一個元組中，先將包含有組的組，看作一個整體也就是一個組，把這個整體組放入一個元組里，然后在把組里的組放入一個元組，最后將所有組放入一個列表返回
r = re.findall("(a)(\w+(e))", origin)
print(r)
# [('a', 'le', 'e'), ('a', 'le', 'e'), ('a', 'le', 'e')]

5、?:在有分組的情況下findall()函數，不只拿分組里的字符串，拿所有匹配到的字符串。

注意?:只用于不是返回正則對象的函數如findall()

import re
origin = "hello alex bcd alex lge alex acd 19"
# ?:在有分組的情況下，不只拿分組里的字符串，拿所有匹配到的字符串，注意?:只用于不是返回正則對象的函數如findall()
b = re.findall("a(?:\w+)", origin)
print(b)
# ['alex', 'alex', 'alex', 'acd']

6、re.split()：根據正則匹配分割字符串，返回分割后的一個列表

split(pattern, string, maxsplit=0, flags=0)

  • pattern： 正則模型
  • string ： 要匹配的字符串
  • maxsplit：指定分割個數
  • flags ： 匹配模式

按照一個字符將全部字符串進行分割

import re
origin = "hello alex bcd alex lge alex acd 19"
r = re.split("a", origin)  # 根據正則匹配分割字符串
print(r)
# ['hello ', 'lex bcd ', 'lex lge ', 'lex ', 'cd 19']

將匹配到的字符串作為分割標準進行分割

import re
origin = "hello alex bcd alex lge alex 2acd 19"
r = re.split("a\w+", origin)  # 根據正則匹配分割字符串
print(r)
# ['hello ', ' bcd ', ' lge ', ' 2', ' 19']

7、 re.sub()：替換匹配成功的指定位置字符串

sub(pattern, repl, string, count=0, flags=0)

  • pattern： 正則模型
  • repl ： 要替換的字符串
  • string ： 要匹配的字符串
  • count ： 指定匹配個數
  • flags ： 匹配模式
import re
origin = "hello alex bcd alex lge alex acd 19"
r = re.sub("a", "替換", origin)  # 替換匹配成功的指定位置字符串
print(r)
# hello 替換lex bcd 替換lex lge 替換lex 替換cd 19

l = ['1 2 ', '2   3', '  3 4']
print(eval(re.sub(r'\s*', '', str(l))))
# ['12', '23', '34']

8、 re.subn()：替換匹配成功的指定位置字符串,并且返回替換次數，可以用兩個變量分別接受

subn(pattern, repl, string, count=0, flags=0)

  • pattern： 正則模型
  • repl ： 要替換的字符串
  • string ： 要匹配的字符串
  • count ： 指定匹配個數
  • flags ： 匹配模式
import re

origin = "hello alex bcd alex lge alex acd 19"
a, b = re.subn("a", "替換", origin)  # 替換匹配成功的指定位置字符串,并且返回替換次數，可以用兩個變量分別接受
print(a)  # hello 替換lex bcd 替換lex lge 替換lex 替換cd 19
print(b)  # 4

原文鏈接：https://www.cnblogs.com/springsnow/p/11972921.html

欄目分類
最近更新