python正則表達式開頭

⑴ python正則表達式指定開始匹配的敵方

一. 簡介

正則表達式又叫規則表達式，是處理字元串的強大工具。在python中通過調用re模塊，可以實現正則匹配，正則表達式模式被編譯成一系列的位元組碼，然後由C編寫的匹配引擎執行

二. python常用字元含義(匹配模式)

1186367-20180604115644788-1913251705.png

三. re模塊

1. re.match(pattern, string, flags=0) | match(string, [pos, endpos]) (這個用於編譯後返回的正則表達式對象Pattern.match())

1)作用：嘗試從字元串的起始位置匹配一個模式，如果起始位置匹配成功，返回一個match對象，否則返回None

pattern：匹配的正則表達式

string：要匹配的字元串

flags：標志位，用於控制正則表達式的匹配方式，如：是否區分大小寫，多行匹配等

2) 正則表達式可以包含一些可選標志修飾符來控制匹配模式。修飾符被指定為一個可選的標志，多個修飾符可以通過 | 來指定，如re.I | re.M表示對大小寫不敏感和多行匹配物卜空

1186367-20180604123302464-360465156.png

3) 實例

importreprint(re.match('www', 'www.runoob.com').span()) #在起始位置匹配

print(re.match('com', 'www.runoob.com')) #不在起始位置匹配

運行結果為：

(0, 3)

None

為什麼第一個起始位置匹配要加span()?

span()的作用是：返回一個元組包含匹配 (開始,結束) 的位置，如果不加span(),我們獲得的只是一個match obj，只有加了span()，我們才能獲得匹配罩瞎對象的位置。不信請看：

#在命令行輸出

print(re.match('www', 'www.runoob.com'))<_sre.SRE_Match object; span=(0, 3), match='www'>

print(re.match('com', 'www.runoob.com'))

None

為什麼第二個非起始位置匹配不加span()?

不在起始位置匹配，默認返回的None，而None對象是沒有span()方法的，這時候就會報錯：

importreprint(re.match('com', 'www.runoob.com').span())

Traceback (most recent call last):

File"", line 1, in

print(re.match('com', 'www.runoob.com').span())

AttributeError: 'NoneType' object has no attribute 'span'

2. re.search(pattern, string, flags=0) | search(string, [pos, endpos])(這個用於編譯後返回的正則表達式對象Pattern.search())

1) 作用：在字元串內查找匹配模式，只要找到第一個匹配則返回一個match對象，如果沒有找到，則返回None

importre#不加span()返回一個match對象

print(re.search('www', 'www.runoob.com'))<_sre.SRE_Match object; span=(0, 3), match='www'>

print(re.search('www', 'www.runoob.com').span())

(0,3)print(re.search('com', 'www.runoob.com').span())

(11, 14)

3. re.match和re.search一旦匹配成功，就會返回一個match object對象，而match object對象有以下方法：

group(num) num代表組號，表示匹配第num組的字元串，不寫時默認是0，表示匹配整個表達式的字元串。group()也可以一次輸入多弊悄個組號，如group(1, 2, 3)，這種情況下它將返回一個包含那些組所對應的元組

groups() 返回一個包含所有小組字元串的元組，從1到所含的小組號

span() 返回一個元組包含匹配(開始、結束)的位置

start() 返回匹配開始的位置

end() 返回匹配結束的位置

1) 實例

importre

line= "Cats are smarter than dogs"searchObj= re.search( r'(.*) are (.*?) .*', line, re.M|re.I)print(searchObj.group())

Cats are smarter than dogsprint(searchObj.group(0))

Cats are smarter than dogsprint(searchObj.group(1))

Catsprint(searchObj.group(2))

smarterprint(searchObj.group(1, 2))

('Cats', 'smarter')

print(searchObj.groups())

('Cats', 'smarter')

為什麼第二組匹配是 (.*?) 而不是 (.*)

我們做個試驗，嘗試一下 (.*)

importre

line= "Cats are smarter than dogs"searchObj= re.search( r'(.*) are (.*) .*', line, re.M|re.I)print(searchObj.group())

Cats are smarter than dogsprint(searchObj.group(1))

Catsprint(searchObj.group(2))

smarter thanprint(searchObj.group(1, 2))

('Cats', 'smarter than')

注意到group(2)的數據是不同的，這個是為什麼呢？這就涉及到貪婪匹配和非貪婪匹配

貪婪匹配： 在整個表達式匹配成功的情況下，盡可能多的匹配。比如上面的 .*

.表示除換行之外的所有字元， *表示匹配前面的字元0次或無數次

非貪婪匹配：在整個表達式匹配成功的情況下，盡可能少的匹配。比圖上面的 .*?

?表示匹配前面字元0次或1次

注意前面 are () .* 中，()前後是兩個空格，而are之後兩個空格之間有兩種情況，1. "smarter than"， 2. "smarter"，具體選擇哪種是由匹配模式決定的，當()里是貪婪匹配時，.*可以匹配smarter，可以匹配空格，可以匹配than，當()里是非貪婪模式時， .*?只會匹配smarter，因為它最多匹配一次

為什麼要用前綴 r 呢？

我們知道在python中, \ 表示轉義字元，如果需要匹配一個 \ 本身呢？我們就要用\\， 而分別對每個 \ 進行轉義，就需要用 \\\\

注意：如果字元串中有字元*需要匹配，可以使用\*或字元集[*]

4. re.compile(pattern, [flags])

1) 作用：用於編譯正則表達式，生成一個正則表達式對象(Pattern，這個Pattern不能直接實例化，必須由re.compile()進行構造)，供match()和search()這兩個函數使用

pattern：一個字元串形式的正則表達式

flags：編譯標志位，用於控制正則表達式的匹配方式，如：是否區分大小寫、多行匹配等

2) 實例1

importre#用於匹配至少一個數字

pattern = re.compile(r'\d+')#從開始位置匹配

m = pattern.match('one12twothree34four')#沒有匹配，返回None

print(m)

None#從"1"的位置開始匹配

m = pattern.match('one12twothree34four', 3, 10)#正好匹配返回一個match對象

print(m)<_sre.SRE_Match object; span=(3, 5), match='12'>

print(m.group())12

print(m.start())3

print(m.end())5

print(m.span())

(3, 5)

實例2

importre#re.I表示忽略大小寫

pattern = re.compile(r'([a-z]+) ([a-z]+)', re.I)

m= pattern.match('Hello World Wide Web')#匹配成功返回一個match對象

print(m)<_sre.SRE_Match object; span=(0, 11), match='Hello World'>

#返回匹配成功的整個子串

print(m.group(0))

Hello World#返回匹配成功的整個子串的索引

print(m.span(0))

(0,11)#返回第一個分組匹配成功的子串

print(m.group(1))

Hello#返回第一個分組匹配成功的子串的索引

print(m.span(1))

(0,5)#返回第二個分組匹配成功的子串

print(m.group(2))

World#返回第二個分組匹配成功的子串的索引

print(m.span(2))

(6, 11)#等價於(m.group(1), m.group(2), ...)

print(m.groups())

('Hello', 'World')#不存在第三個分組

print(m.group(3))

Traceback (most recent call last):

File"", line 1, in

print(m.group(3))

IndexError: no such group

5. re.findall(pattern, string, flags=0) | findall(string, [pos, endpos])

1) 作用：遍歷匹配，以列表形式返回所有能匹配的子串，如果沒找到匹配的，則返回空列表

string：待匹配的字元串

pos：可選參數，指定字元串的起始位置，默認為0

endpos：可選參數，指定字元串的結束位置，默認為字元串的長度

2) 實例

importre#查找數字

pattern = re.compile(r'\d+')

result1= pattern.findall('runoob 123 google 456')print(result1)

['123', '456']

result2= pattern.findall('run88oob123google456', 0, 10)print(result2)

['88', '12']

6. re.finditer(pattern, string, flags=0) | finditer(string, [pos, endpos])

1) 作用：搜索string，返回一個順序訪問每一個匹配結果(match對象)的迭代器。找到匹配的所有子串，並把它們作為一個迭代器返回。

2) 實例

importre

pattern= re.compile(r'\d+')print(pattern.finditer('one1two2three3four4'))

for m in pattern.finditer('one1two2three3four4'):print(m)print(m.group())<_sre.SRE_Match object; span=(3, 4), match='1'>

1

<_sre.SRE_Match object; span=(7, 8), match='2'>

2

<_sre.SRE_Match object; span=(13, 14), match='3'>

3

<_sre.SRE_Match object; span=(18, 19), match='4'>

4

7. re.split(pattern, string, [maxsplit=0, flags=0]) | split(string, [maxsplit])

1) 作用：按照能夠匹配的子串將字元串分割後返回列表

pattern：匹配的正則表達式

string：要匹配的字元串

maxsplit：分割次數，maxsplit=1 分割一次，默認為0，不限制次數

flags：標志位，用於控制正則表達式的匹配方式，如：是否區分大小寫、多行匹配等

2) 實例1

importre

pattern= re.compile(r'\d+')print(pattern.split('one1two2three3four4'))

['one', 'two', 'three', 'four', ''] #注意後面沒有內容，是一個''字元

實例2

importre#匹配\W+表示非單詞字元一次或無數次

pattern = re.compile(r'\W+')#用非單詞字元分割

print(pattern.split('hello, world'))

['hello', 'world']

使用帶括弧的正則表達式則可以將正則表達式匹配的內容也添加到列表內

importre#帶括弧的正則表達式則可以將正則表達式匹配的內容也添加到列表內

pattern = re.compile(r'(\W+)')print(pattern.split('hello, world'))

['hello', ', ', 'world']

⑵ python正則表達式是什麼

python正則表達式是：

'hing'

'wing'

'123456'

'dddddd'

'regex.py'

'.*.py'

正則表達式（簡稱為 regex）是一些由字元和特殊符號組成的字元串， 描述了模式的重復或者表述多個字元。正則表達式能按照某種模式匹配一系列有相似特徵的字元串。換句話說， 它們能夠匹配多個字元串。

孤立的一個正則表達式並不能起到匹配字元串的作用，要讓其能夠匹配目標字元，需要創建一個正則表達式對象。通常向compile()函數傳入一個原始字元形式的正則表達式，即 r'.....'。

要讓正則表達式不區分大小寫，可以向re.compile()傳入re.IGNORECASE或re.I，作為第二個參數。通過傳入re.DOTALL作為re.compile()的第二個參數，可以讓句點字元匹配所有字元，包括換行字元。

⑶ 用python正則表達式，截取一段字元串中以「[」開頭，以「]」結束的字元串

importre
a="asdf[abc123]我們"
g=re.search("[.*]",a)
ifg:
print(g.group())
else:
print("")

看看這個是不是你想要的效果，最後列印的是[abc123]，如果你[]不想要，可以在匹配完成後手動去掉字元串的第一個和最後一個字元

⑷ 請問python編程中怎麼用正則表達式來編寫一個程序，從而判斷輸入的數是否為浮點數。求高手指教。

1.程序如下：

importre

number=str(input("Pleaseinputanumber:"))

pattern=re.compile(r'^[-+]?[0-9]+.[0-9]+$')

match=pattern.match(number)

ifmatch:

print"Numberisafloat."

else:

print"Numberisnotafloat."

2.關於這個正則表達式，解釋一下：

^[-+]?[0-9]+.[0-9]+$

^表示以這個字元開頭，也就是以[-+]開頭，[-+]表示字元-或者+之一，

?表示0個或1個，也就是說符號是可選的。

同理[0-9]表示0到9的一個數字，+表示1個或多個，也就是整數部分。

.表示的是小數點，是轉義字元因為.是特殊符號（匹配任意單個除 之外的字元），

所以需要轉義。

小數部分同理，$表示字元串以此結尾。

3.關於正則表達式，根據需要有好幾種寫法：

1.強制符號、整數、小數和指數

^[-+][0-9]+.[0-9]+[eE][-+]?[0-9]+$

2.強制符號、整數、小數，沒有指數

^[-+][0-9]+.[0-9]+$

3.可選符號，強制整數、小數，沒有指數

^[-+]?[0-9]+.[0-9]+$

4或更多，見下文：

http://blog.csdn.net/guaguastd/article/details/39184407

P.S.：例子中的是第三種寫法。

4. 測試結果：

⑸ Python中正則表達式的常用元字元有哪些呢

Python 中常用的正則表達式元字元包括：

1. .：匹配任意一個字元（除了換行符 ）。

2. ^：匹配字元串的開頭。

3. $：匹配字元串的結尾。

4. *：匹配前面的字元 0 次或多次。

5. +：匹配前面的字元 1 次或多次。

6. ?：匹配前面的字元 0 次或 1 次。

7. {n}：匹配前面的字元恰好 n 次。

8. {m,n}：匹配前面的字元至少 m 次，至多 n 次。

9. []：匹配方括弧內的任意一個字元。

10. ()：標記一個子表達式的開始和結束位置。

11. |：表示或，匹配符號左右兩邊的任意一個表達式。

12. ：用來轉義元字元或者表示特殊字元。

這些耐散元字元在正則表達式晌畝握中經常使用，可以組合成各種復雜的宴慶正則表達式，用於字元串的匹配和替換等操作。

⑹ python 正則表達式，怎樣匹配以某個字元串開頭，以某個字元串結尾的情況

python正則匹配以xx開頭以xx結尾的單詞的步驟：

1、假設需要匹配的字元串為：site sea sue sweet see case sse ssee loses需要匹配的為以s開頭以e結尾的單詞。正確的正則式為：sS*?e

2、使用python中re.findall函數表示匹配字元串中所有的可能選項，re是python里的正則表達式模塊。findall是其中一個方法，用來按照提供的正則表達式，去匹配文本中的所有符合條件的字元串。

3、代碼和結果如下：

text ='site sea sue sweet see case sse ssee loses'

re.findall(r'sS*?e',text)

結果為：['site', 'sue', 'see', 'sse', 'ssee']

(6)python正則表達式開頭擴展閱讀：

python正則匹配,以某某開頭某某結尾的最長子串匹配

代碼如下：

regVersions = re.search(r'(V|v)[0-9].*[0-9]', filename)

if regVersions:

print regVersions.group()