通過python的正則表達式re模塊匹配出html標

通過python的正則表達式re模塊匹配出html標簽以及內容

代碼如下：

#以下代碼是通過python的正則表達式re模塊匹配出html標簽以及內容
import re #必須導入內置的正則表達式re模塊
info='<html><h2>zhangsan</h2></html>'
#上面一行代碼定義info為html標簽內容，包含2個標簽，第1個標簽是html,第2個標簽是h2，標簽內容是zhangsan
pattern1=re.compile(r'<(\w+)><(\w+)>(.+)</\2></\1>$')
#上面這行代碼的(\w+)代表至少1個數字字母下劃線，(.+)匹配除換行符 \n 之外的任何至少1個單字符，</\2>代表第2個標簽的</h2>,</\1>代表第1個標簽的</html>
result1=re.match(pattern1,info)
#上面這行代碼代表從頭開始匹配info里符合正則規則pattern1的內容，并賦值給result1
print("result1:",result1)
print("result1.group():",result1.group())
#上面這行代碼代表要打印匹配出來的所有結果，group()代表所有的
print("result1.group(1):",result1.group(1))
#上面這行代碼代表要打印匹配出來的第一個結果，group(1)代表第一個結果
print("result1.group(2):",result1.group(2))
#上面這行代碼代表要打印匹配出來的第二個結果，group(2)代表第二個結果
print("result1.group(3):",result1.group(3))
#上面這行代碼代表要打印匹配出來的第三個結果，group(3)代表第三個結果

代碼運行結果如下：

result1: <re.Match object; span=(0, 30), match='<html><h2>zhangsan</h2></html>'>

result1.group(): <html><h2>zhangsan</h2></html>

result1.group(1): html

result1.group(2): h2

result1.group(3): zhangsan

圖片示例如下：

濾html

value=re.sub('<[^>]+>','', value)

import re
 
value='''
<div> sdb</div>
'''
 
value=re.sub('<[^>]+>','', value) #過濾HTML標簽
value

'\n sdb\n'

value.replace('\n',' ')

過濾亂碼re.sub()

函數說明sub(pattern,repl,string)把字符串中的所有匹配表達式pattern中的地方替換成repl[^**]表示不匹配此字符集中的任何一個字符\u4e00-\u9fa5漢字的unicode范圍\u0030-\u0039數字的unicode范圍\u0041-\u005a大寫字母unicode范圍\u0061-\u007a小寫字母unicode范圍

import re
string="北京大學beijing985大學@#￥……&{}*@$%）..+_)("
str=re.sub(u"([^\u4e00-\u9fa5\u0030-\u0039\u0041-\u005a\u0061-\u007a])","",string)
print(str)

北京大學beijing985大學

# 提取中文
str=re.sub(u"([^\u4e00-\u9fa5])","",string)
print(str )

北京大學大學

# 提取中文和數字
str=re.sub(u"([^\u4e00-\u9fa5\u0030-\u0039])","",string)
print(str )

北京大學985大學

獲取<tr></tr>標簽之間內容

res_tr=r'<tr>(.*?)</tr>'
m_tr=re.findall(res_tr,language,re.S|re.M)

import re
 
language='''<tr><th>性別：</th><td>男</td></tr><tr>'''
 
res_tr=r'<tr>(.*?)</tr>'
m_tr=re.findall(res_tr,language,re.S|re.M)
for line in m_tr:
    print(line)
    #獲取表格第一列th 屬性
    res_th=r'<th>(.*?)</th>'  
    m_th=re.findall(res_th,line,re.S|re.M)
    for mm in m_th:
        print("<th>",mm)
    #獲取表格第二列td 屬性值
    res_td=r'<td>(.*?)</td>'
    m_td=re.findall(res_td,line,re.S|re.M)
    for nn in m_td:
         print("<td>",nn)

<th>性別：</th><td>男</td>
<th> 性別：
<td> 男

獲取超鏈接<a href=..></a>之間內容

res=r'<a .*?>(.*?)</a>'
mm= re.findall(res, content, re.S|re.M)
urls=re.findall(r"<a.*?href=.*?<\/a>", content, re.I|re.S|re.M)

# coding=utf-8
import re

content='''''
<td>
<a href="www.kklike.com" title="ab">abc</a>
<a href="www.kklike.com" title="cd">cde</a>
</td>
'''

# 獲取<a href></a>之間的內容
print(u'獲取鏈接文本內容:')
res=r'<a .*?>(.*?)</a>'
mm=re.findall(
    res, content, re.S | re.M)
for value in mm:
    print(value)

# 獲取所有<a href></a>鏈接所有內容
print(u'\n獲取完整鏈接內容:')
urls=re.findall(r"<a.*?href=.*?<\/a>", content, re.I | re.S | re.M)
for i in urls:
    print(i)

# 獲取<a href></a>中的URL
print(u'\n獲取鏈接中URL:')
res_url=r"(?<=href=\").+?(?=\")|(?<=href=\').+?(?=\')"
link=re.findall(res_url, content, re.I | re.S | re.M)
for url in link:
    print(url)

獲取鏈接文本內容:
abc
cde

獲取完整鏈接內容:
<a href="www.kklike.com" title="ab">abc</a>
<a href="www.kklike.com" title="cd">cde</a>

獲取鏈接中URL:
www.kklike.com
www.kklike.com

獲取URL最后一個參數命名圖片或傳遞參數

urls="http://www.kklike.com/BbsImg141568417848931_640*640.jpg"
values=urls.split('/')[-1]
values

'BbsImg141568417848931_640*640.jpg'

url='http://www.kklike.com/test.py?a=hello&b=world'  
values=url.split('?')[-1]  
print(values)
for key_value in values.split('&'):
    print(key_value.split('='))

a=hello&b=world
['a', 'hello']
['b', 'world']

爬取網頁中所有URL鏈接

# coding=utf-8
import re
import urllib

url="http://www.kklike.com/"
content=urllib.request.urlopen(url).read().decode("utf8")
# print(content)
urls=re.findall(r"<a.*?href=.*?<\/a>", content, re.I)
print(urls[:3])

link_list=re.findall(r"(?<=href=\").+?(?=\")|(?<=href=\').+?(?=\')", content)
print(link_list[:3])

['<a href="http://www.kklike.com">kklike</a>', '<a href="/" title="首頁"><img src="/images/finwod.png" alt="首頁"/></a>', '<a href="/image.do" title="圖片上傳"><img src="/images/upload.png" alt="圖片上傳"></img></a>']
['/images/favicon.ico', '/styles/kklike.css', "/styles/kklike.css?v=' + now + '"]

爬取網頁標題title兩種方法

# coding=utf-8
import re
import urllib

url="http://www.kklike.com/"
content=urllib.request.urlopen(url).read().decode("utf8")

title_pat=r'(?<=<title>).*?(?=</title>)'
title_ex=re.compile(title_pat, re.M | re.S)
title_obj=re.search(title_ex, content)
title=title_obj.group()
print(title)

title=re.findall(r'<title>(.*?)</title>', content)
print(title[0])

www.kklike.com--流著看看（圖文愛好者）
www.kklike.com--流著看看（圖文愛好者）

定位table位置并爬取屬性-屬性值

# coding=utf-8  
import re

content='''sdf<table class="infobox vevent"><tr><td></td></tr></table>sdf ''';

start=content.find(r'<table class="infobox vevent"') #起點記錄查詢位置
end=content.find(r'</table>')
infobox=content[start:end]
print(infobox)

<table class="infobox vevent"><tr><td></td></tr>

s='''<table>   
<tr>   
<td>序列號</td><td>DEIN3-39CD3-2093J3</td>   
<td>日期</td><td>2013年1月22日</td>   
<td>售價</td><td>392.70 元</td>   
<td>說明</td><td>僅限5用戶使用</td>   
</tr>   
</table> 
'''
res=r'<td>(.*?)</td><td>(.*?)</td>'
m=re.findall(res, s, re.S | re.M)
for line in m:
    print(line[0],line[1])
    
# pandas.read_html()

序列號 DEIN3-39CD3-2093J3
日期 2013年1月22日
售價 392.70 元
說明 僅限5用戶使用

過濾<span></span>等標簽

在獲取值過程中，通常會存在<span>、<br>、<a href>等標簽，下面舉個例子過濾。

<td><span class="nickname">(字) 翔宇</span></td>過濾標簽

if "span" in nn: #處理標簽<span>
    res_value=r'<span .*?>(.*?)</span>'
    m_value=re.findall(res_value,nn,re.S|re.M) 
    for value in m_value:
        print(value)

# coding=utf-8
import re

language='''
<table class="infobox bordered vcard" style="width: 21em; font-size: 89%; text-align: left;" cellpadding="3">
<caption style="text-align: center; font-size: larger;" class="fn"><b>kklike</b></caption>
<tr><th>site：</th><td>kklike.com</td></tr>
<tr><th>title：</th><td> 圖文愛好者</td></tr>
</tr>
</table>
'''

# 獲取table中tr值
res_tr=r'<tr>(.*?)</tr>'
m_tr=re.findall(res_tr, language, re.S | re.M)
for line in m_tr:
    # 獲取表格第一列th 屬性
    res_th=r'<th>(.*?)</th>'
    m_th=re.findall(res_th, line, re.S | re.M)
    for mm in m_th:
        if "href" in mm:  # 如果獲取加粗的th中含超鏈接則處理
            restr=r'<a href=.*?>(.*?)</a>'
            h=re.findall(restr, mm, re.S | re.M)
            print(h[0])
        else:
            print(mm,end=' ')

    # 獲取表格第二列td 屬性值
    res_td=r'<td>(.*?)</td>'  # r'<td .*?>(.*?)</td>'
    m_td=re.findall(res_td, line, re.S | re.M)
    for nn in m_td:
        if "href" in nn:  # 處理超鏈接<a href=../rel=..></a>
            res_value=r'<a .*?>(.*?)</a>'
            m_value=re.findall(res_value, nn, re.S | re.M)
            for value in m_value:
                print(value)
        elif "span" in nn:  # 處理標簽<span>
            res_value=r'<span .*?>(.*?)</span>'
            m_value=re.findall(res_value, nn, re.S | re.M)  # <td><span class="nickname">(字) 翔宇</span></td>
            for value in m_value:
                print(value)
        else:
            print(nn)

site： kklike.com
title：  圖文愛好者

獲取<script></script>等標簽內容

# coding=utf-8
import re
import os,urllib

content='''''
<script>var images=[
{ "original":"http://shop.kklike.com/_image/upload/2014/107b4495-4860-4b76-b807-d7f81e27f4a8.jpg",
  "title":"","descript":"","id":75109},
{ "original":"http://shop.kklike.com/_image/upload/2014/107b4495-4860-4b76-b807-d7f81e27f4a8.jpg",
  "title":"","descript":"","id":75110},
</script>
'''

html_script=r'<script>(.*?)</script>'
m_script=re.findall(html_script, content, re.S | re.M)
for script in m_script:
    res_original=r'"original":"(.*?)"'  # 原圖
    m_original=re.findall(res_original, script)
    for pic_url in m_original:
        print
        pic_url
        filename=os.path.basename(pic_url)  # 去掉目錄路徑,返回文件名
        urllib.request.urlretrieve(pic_url,  "image/"+filename)  # 下載圖片

from IPython.display import display, Image,Video,HTML
display(Image('image/'+filename,width=200))

通過replace過濾<br />標簽

if '<br />' in value:
    value=value.replace('<br />','')   #過濾該標簽
    value=value.replace('\n',' ')         #換行空格替代 否則總換行

獲取<img ../>中超鏈接及過濾<img>標簽

re.findall('src="(.*?)"'

import re
test='''<img alt="圖文愛好者" src="../images/kklike.png" width="19" height="19" border="0" />'''
print(re.findall('src="(.*?)"',test))

['../images/kklike.png']

計更新

第一章. Python 簡介

- Python 簡介和歷史

- Python 特點和優勢

- 安裝 Python

第二章. 變量和數據類型

- 變量和標識符

- 基本數據類型：數字、字符串、布爾值等

- 字符串操作

- 列表、元組和字典

第三章. 控制語句和函數

- 分支結構：if/else 語句

- 循環結構：for 和 while 循環

- 函數

- 參數傳遞與返回值

- Lambda 表達式

第四章. 模塊和文件 IO

- 模塊的概念

- 導入模塊

- 文件 IO

- 序列化和反序列化

第五章. 異常處理

- 異常簡介

- try/except 語句

- 自定義異常

第六章. 面向對象編程

- 類和對象

- 繼承和多態

- 屬性和方法

- 抽象類和接口

第七章. 正則表達式

- 正則表達式概述

- 匹配和搜索

- 替換和分割

第八章. 并發編程

- 多線程

- 多進程

- 協程和異步編程

第九章. 數據庫編程

- 關系型數據庫介紹

- 使用 SQLite 數據庫

- 使用 MySQL 數據庫

- 使用 PostgreSQL 數據庫

第十章. 網絡編程

- Socket 編程簡介

- TCP Socket 編程

- UDP Socket 編程

- HTTP 編程

第十一章. Web 開發框架 Flask

- Flask 簡介

- 安裝 Flask

- 路由和視圖函數

- 模板和靜態文件

第十二章. 數據分析和科學計算

- NumPy 基礎

- Pandas 基礎

- Matplotlib 基礎

第十三章機器學習入門

- 機器學習概述

- 監督學習和非監督學習

- Scikit-Learn 簡介

- 利用 Scikit-Learn 進行數據預處理和模型訓練

第十四章. 自然語言處理

- 自然語言處理概述

- 中文分詞和處理

- 文本分類和情感分析

第十五章. 游戲開發與 Pygame

- Pygame 簡介

- Pygame 基礎

- 開發一個簡單的游戲

第七章. 正則表達式

- 正則表達式概述

- 匹配和搜索

- 替換和分割

正則表達式概述

在Python中，正則表達式是一種強大的文本處理工具，可以幫助我們快速、方便、精準地匹配和替換字符串。正則表達式以特定的符號和語法來表示一些規則和模式，用于描述字符串的組成和格式。在本文中，我們將詳細介紹Python中的正則表達式，包括基本概念、語法、應用場景及常見問題等內容，希望能夠為讀者提供實用的指導和幫助。

一、基本概念

1. 正則表達式

正則表達式（Regular Expression）是一種描述字符串結構的表達式，通常由特定的符號和語法組成。正則表達式可以用于搜索、匹配、替換和驗證字符串，是文本處理中非常重要的工具之一。

以下是一個簡單的正則表達式示例：

```

import re

pattern=r'hello'

string='hello world'

match=re.search(pattern, string)

if match:

print('Match found')

else:

print('Match not found')

```

在上述代碼中，我們使用re模塊定義了一個名為“pattern”的正則表達式，并使用search()方法在字符串“string”中查找是否存在該表達式。如果匹配成功，則輸出“Match found”，否則輸出“Match not found”。

2. 元字符

在正則表達式中，元字符是一些特殊字符，用于表示特定的規則和模式。常見的元字符包括“.”、“*”、“+”、“?”、“^”、“$”等。

以下是一些常見的元字符及其含義：

- “.”：匹配任意單個字符（除換行符外）。

- “*”：匹配前一個字符的 0 或多次重復。

- “+”：匹配前一個字符的 1 或多次重復。

- “?”：匹配前一個字符的 0 或 1 次重復。

- “^”：匹配字符串開頭。

- “$”：匹配字符串結尾。

3. 字符類

在正則表達式中，字符類是一些預定義的字符集合，可以用于匹配特定類型的字符。常見的字符類包括“\d”、“\w”、“\s”等。

以下是一些常見的字符類及其含義：

- “\d”：匹配任意數字字符（0-9）。

- “\w”：匹配任意字母、數字或下劃線字符。

- “\s”：匹配任意空白字符（空格、制表符、換行符等）。

需要注意的是，字符類也可以使用“[]”來自定義，例如“[abc]”可以匹配a、b、c三個字符中的任意一個。

4. 分組和捕獲

在正則表達式中，分組和捕獲是一種將多個元素組合到一起的機制，可以用于匹配和替換字符串。分組和捕獲通常使用“()”來表示。

以下是一個簡單的分組和捕獲示例：

```

import re

pattern=r'(\d{3})-(\d{4})'

string='123-4567'

match=re.search(pattern, string)

if match:

print('Match found')

area_code=match.group(1)

number=match.group(2)

print(f'Area code: {area_code}')

print(f'Number: {number}')

else:

print('Match not found')

```

在上述代碼中，我們使用了兩個分組來匹配電話號碼的區號和號碼部分，并使用group()方法來捕獲這些分組。如果匹配成功，則輸出“Match found”，并輸出區號和號碼內容。

5. 貪婪和非貪婪模式

在正則表達式中，貪婪和非貪婪模式是一種控制匹配重復次數的機制。貪婪模式盡可能多地匹配重復內容，而非貪婪模式盡可能少地匹配重復內容。

以下是一個簡單的貪婪和非貪婪模式示例：

```

import re

pattern=r'<.*>'

string='<a>hello</a><b>world</b>'

match=re.search(pattern, string)

if match:

print('Greedy match found:', match.group())

else:

print('Greedy match not found')

pattern=r'<.*?>'

match=re.search(pattern, string)

if match:

print('Non-greedy match found:', match.group())

else:

print('Non-greedy match not found')

```

在上述代碼中，我們使用了兩個正則表達式來匹配HTML標簽中的內容。第一個正則表達式使用了貪婪模式，嘗試匹配盡可能多的字符，導致匹配結果包含了多個HTML標簽的內容。第二個正則表達式使用了非貪婪模式，嘗試匹配盡可能少的字符，導致匹配結果只包含了第一個HTML標簽的內容。

二、語法

Python中的正則表達式語法相對簡單，主要由元字符、字符類、分組和捕獲、修飾符等組成。以下是一些常見的語法元素及其含義：

1. 元字符

元字符是正則表達式中最基本、最重要的語法元素之一，用于表示特定的規則和模式。常見的元字符包括“.”、“*”、“+”、“?”、“^”、“$”等。

2. 字符類

字符類是一些預定義的字符集合，可以用于匹配特定類型的字符。常見的字符類包括“\d”、“\w”、“\s”等。需要注意的是，字符類也可以使用“[]”來自定義。

3. 分組和捕獲

分組和捕獲是一種將多個元素組合到一起的機制，可以用于匹配和替換字符串。分組和捕獲通常使用“()”來表示。

4. 修飾符

修飾符是一些用于修改正則表達式行為的標記，可以在正則表達式開頭使用。常見的修飾符包括“i”（忽略大小寫）、“m”（多行模式）、“s”（點任意匹配模式）等。

以下是一些常見的正則表達式語法示例：

- 匹配任意單個字符：用“.”表示。

- 匹配前一個字符的 0 或多次重復：用“*”表示。

- 匹配前一個字符的 1 或多次重復：用“+”表示。

- 匹配前一個字符的 0 或 1 次重復：用“?”表示。

- 匹配字符串開頭：用“^”表示。

- 匹配字符串結尾：用“$”表示。

- 匹配任意數字字符（0-9）：用“\d”表示。

- 匹配任意字母、數字或下劃線字符：用“\w”表示。

- 匹配任意空白字符（空格、制表符、換行符等）：用“\s”表示。

- 使用自定義字符類匹配特定字符：用“[]”表示，例如“[abc]”表示匹配a、b、c三個字符中的任意一個。

- 使用分組和捕獲匹配多個元素：用“()”表示，例如“(\d{3})-(\d{4})”表示匹配電話號碼的區號和號碼部分。

- 使用修飾符修改正則表達式行為：在正則表達式開頭使用，例如“re.I”表示忽略大小寫模式。

三、應用場景

Python中的正則表達式可以應用于各種文本處理場景，包括數據清洗、字符串匹配與替換、HTML/XML解析等。以下是一些常見的應用場景：

1. 數據清洗

在數據處理中，我們經常需要對文本數據進行清洗和格式化。通過使用正則表達式，我們可以快速、方便地匹配和替換不規范、重復、無效或錯誤的數據內容。

以下是一個簡單的數據清洗示例：

```

import re

pattern=r'\d{4}-\d{2}-\d{2}'

string='2023-03-25'

match=re.search(pattern, string)

if match:

print('Match found')

formatted_date=match.group().replace('-', '/')

print(f'Formatted date: {formatted_date}')

else:

print('Match not found')

```

在上述代碼中，我們使用了一個正則表達式來匹配日期格式，并使用group()方法捕獲該日期內容。如果匹配成功，則輸出“Match found”，并將日期中的“-”替換為“/”，得到格式化后的日期。

2. 字符串匹配與替換

在字符串處理中，我們經常需要根據特定的規則和模式對字符串進行匹配和替換。通過使用正則表達式，我們可以實現高效、精準的字符串匹配和替換操作。

以下是一個簡單的字符串匹配與替換示例：

```

import re

pattern=r'\b\d{4}\b'

string='1234 hello 5678 world'

replaced_string=re.sub(pattern, '****', string)

print(f'Original string: {string}')

print(f'Replaced string: {replaced_string}')

```

在上述代碼中，我們使用了一個正則表達式來匹配四位數字，并使用sub()方法將其替換為“****”。輸出結果中可以看到原始字符串和替換后的字符串。

3. HTML/XML解析

在Web開發中，我們經常需要對HTML/XML等文檔格式進行解析和處理。通過使用Python的正則表達式，我們可以快速、方便地提取文檔內容，實現高效的數據抽取和分析。

以下是一個簡單的HTML解析示例：

```

import re

pattern=r'<h1>(.*?)</h1>'

string='<html><body><h1>Hello world!</h1><p>This is a paragraph.</p></body></html>'

matches=re.findall(pattern, string)

for match in matches:

print(match)

```

在上述代碼中，我們使用了一個正則表達式來匹配HTML文檔中的一級標題內容，并使用findall()方法捕獲所有匹配項。輸出結果中可以看到所有匹配的標題內容。

四、常見問題

在使用Python的正則表達式時，我們可能會遇到一些常見的問題和錯誤。以下是一些常見的問題及其解決方法：

1. 匹配不到內容

如果正則表達式無法匹配到任何內容，可能是表達式本身有誤或者輸入的字符串不符合預期格式。需要仔細檢查正則表達式和輸入字符串，并確保它們符合預期。

2. 匹配結果不正確

如果正則表達式匹配結果與預期不符，可能是表達式中有誤或者使用了錯誤的捕獲方式。需要仔細檢查正則表達式和捕獲方式，并嘗試調整和優化。

3. 性能問題

如果正則表達式運行速度較慢或消耗大量資源，可能是表達式本身復雜或輸入數據量過大。需要嘗試優化正則表達式和程序邏輯，以提高性能和效率。

總之，Python中的正則表達式是一種強大、高效的文本處理工具，可應用于各種場景，如數據清洗、字符串匹配與替換、HTML/XML解析等。在使用正則表達式時，需要仔細理解其語法和行為，同時注意常見問題和錯誤，并進行適當的優化和調整，以實現高效、精準的文本處理操作。

匹配和搜索

一、背景

在Python語言中，正則表達式是一種強大的文本處理工具，可用于匹配、搜索、替換、分割等多種操作。正則表達式通常使用特定的語法規則來描述和匹配字符串模式，可以幫助我們快速、準確地處理文本數據。

Python中提供了re模塊來支持正則表達式操作，該模塊提供了一系列函數和方法，用于編譯、匹配、搜索、替換和分割字符串。下面我們將詳細介紹Python中正則表達式的匹配和搜索功能。

二、re模塊基礎

在開始使用Python進行正則表達式匹配和搜索前，我們需要先了解一些基礎知識和概念。下面介紹一些常見的概念：

1. 正則表達式

正則表達式是一種用于描述和匹配字符串模式的語言，常用于數據清洗、字符串搜索、分割與替換等場景。正則表達式采用特定的語法規則表示字符串模式，通常由元字符、轉義字符、字符集合、重復次數、分組、捕獲等多個部分組成。

2. 匹配對象

匹配對象是指通過正則表達式匹配到的特定字符串片段，通常由MatchObject對象封裝。MatchObject對象包含匹配到的字符串內容、起始和結束位置、分組等信息。

3. re模塊

re模塊是Python中提供的正則表達式處理模塊，該模塊提供了一系列函數和方法，用于編譯、匹配、搜索、替換和分割字符串。在使用re模塊前，我們需要先導入該模塊。

4. 編譯對象

編譯對象是指通過re.compile()函數編譯生成的正則表達式對象，通常可以直接使用該對象進行匹配和搜索操作。編譯對象可以幫助我們快速復用正則表達式，提高程序性能和效率。

三、正則表達式匹配

Python中的正則表達式匹配功能主要由re模塊提供。下面介紹一些常用的正則表達式匹配函數和方法。

1. re.match()

re.match()函數用于從字符串開頭開始匹配正則表達式，并返回匹配對象。如果在字符串開頭無法匹配，則返回None。該函數的語法格式如下：

```

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

```

其中，pattern表示正則表達式，string表示要匹配的字符串，flags表示匹配標志。該函數返回一個MatchObject對象。

以下是一個簡單的re.match()示例：

```

import re

pattern=r'hello'

string='hello world'

match=re.match(pattern, string)

if match:

print('Match found:', match.group())

else:

print('Match not found')

```

在上述代碼中，我們使用re.match()函數從字符串開頭開始匹配“hello”字符串，并返回匹配對象。如果匹配成功，則輸出“Match found”，并輸出匹配到的內容。

需要注意的是，re.match()函數只會匹配字符串開頭的內容。如果要匹配整個字符串，可以使用re.search()函數或在正則表達式開頭加上“^”符號。

2. re.search()

re.search()函數用于搜索字符串中第一個與正則表達式匹配的內容，并返回匹配對象。該函數的語法格式如下：

```

re.search(pattern, string, flags=0)

```

其中，pattern表示正則表達式，string表示要搜索的字符串，flags表示匹配標志。該函數返回一個MatchObject對象。

以下是一個簡單的re.search()示例：

```

import re

pattern=r'world'

string=' hello world'

match=re.search(pattern, string)

if match:

print('Match found:', match.group())

else:

print('Match not found')

```

在上述代碼中，我們使用re.search()函數搜索字符串中第一個匹配“world”字符串的內容，并返回匹配對象。如果匹配成功，則輸出“Match found”，并輸出匹配到的內容。

需要注意的是，re.search()函數會在整個字符串中搜索第一個匹配項。如果要精確匹配字符串開頭的內容，可以使用re.match()函數或在正則表達式開頭加上“^”符號。

3. re.findall()

re.findall()函數用于搜索字符串中所有與正則表達式匹配的內容，并以列表形式返回。該函數的語法格式如下：

```

re.findall(pattern, string, flags=0)

```

其中，pattern表示正則表達式，string表示要搜索的字符串，flags表示匹配標志。該函數返回一個包含所有匹配結果的列表。

以下是一個簡單的re.findall()示例：

```

import re

pattern=r'\d+'

string='123 apple 456 banana 789 orange'

matches=re.findall(pattern, string)

print(matches)

```

在上述代碼中，我們使用re.findall()函數搜索字符串中所有匹配數字的內容，并返回所有匹配結果的列表。輸出結果中可以看到所有匹配的數字內容。

需要注意的是，re.findall()函數會返回所有匹配結果，而不僅限于第一個匹配項。

四、正則表達式搜索

除了匹配功能外，Python中的正則表達式還支持搜索功能。搜索功能主要由re模塊提供，下面介紹一些常用的正則表達式搜索函數和方法。

1. re.compile()

re.compile()函數用于將正則表達式編譯成一個對象，通常可以直接使用該對象進行匹配和搜索操作。該函數的語法格式如下：

```

re.compile(pattern, flags=0)

```

其中，pattern表示要編譯的正則表達式，flags表示編譯標志。

以下是一個簡單的re.compile()示例：

```

import re

pattern=r'hello'

regex_obj=re.compile(pattern)

string1='hello world'

string2='hi there'

match1=regex_obj.search(string1)

match2=regex_obj.search(string2)

if match1:

print('Match found in string1:', match1.group())

else:

print('Match not found in string1')

if match2:

print('Match found in string2:', match2.group())

else:

print('Match not found in string2')

```

在上述代碼中，我們使用re.compile()函數將正則表達式“hello”編譯成對象，并分別在兩個字符串中進行搜索操作。如果匹配成功，則輸出“Match found”，并輸出匹配到的內容。

需要注意的是，re.compile()函數會將正則表達式編譯成一個對象，通常可以多次復用該對象進行匹配和搜索操作。這樣可以提高程序性能和效率。

2. re.finditer()

re.finditer()函數用于搜索字符串中所有與正則表達式匹配的內容，并以迭代器形式返回。該函數的語法格式如下：

```

re.finditer(pattern, string, flags=0)

```

其中，pattern表示正則表達式，string表示要搜索的字符串，flags表示匹配標志。該函數返回一個包含所有匹配結果的迭代器。

以下是一個簡單的re.finditer()示例：

```

import re

pattern=r'\d+'

string='123 apple 456 banana 789 orange'

matches=re.finditer(pattern, string)

for match in matches:

print(match.group())

```

在上述代碼中，我們使用re.finditer()函數搜索字符串中所有匹配數字的內容，并返回所有匹配結果的迭代器。使用for循環遍歷迭代器，輸出所有匹配的數字內容。

需要注意的是，re.finditer()函數會返回所有匹配結果，而不僅限于第一個匹配項。

3. re .finditer()

re.finditer()函數和re.findall()函數類似，都可以用于搜索字符串中所有符合正則表達式的內容。不同之處在于，re.finditer()返回的是一個迭代器對象，而不是列表對象。這個迭代器對象可以用于遍歷搜索結果，從而進行后續的操作。

下面是一個簡單的re.finditer()示例：

```

import re

pattern=r'\w+'

string='hello world'

matches=re.finditer(pattern, string)

for match in matches:

print(match.group())

```

在上述代碼中，我們使用re.finditer()函數搜索字符串中所有匹配單詞字符的內容，并返回所有匹配結果的迭代器。使用for循環遍歷迭代器，輸出所有匹配的單詞內容。

需要注意的是，re.finditer()函數會返回所有匹配結果，而不僅限于第一個匹配項。同時，它也比re.findall()更加靈活，可以動態處理每個匹配項。

五、正則表達式高級用法

除了基礎的匹配和搜索功能外，Python中的正則表達式還支持一些高級用法。下面介紹一些常見的正則表達式高級用法。

1. 匹配重復次數

正則表達式中可以通過指定重復次數來匹配特定的文本模式。例如，使用“\d{3}”可以匹配連續的3個數字字符。下面是一些常見的重復次數用法：

- *：匹配0個或多個重復項

- +：匹配1個或多個重復項

- ?：匹配0個或1個重復項

- {n}：匹配指定次數的重復項

- {n,}：匹配至少n次的重復項

- {n,m}：匹配至少n次，最多m次的重復項

下面是一個簡單的示例：

```

import re

pattern=r'\d{3}-\d{2}-\d{4}'

string='My SSN is 123-45-6789'

match=re.search(pattern, string)

if match:

print('Match found:', match.group())

else:

print('Match not found')

```

在上述代碼中，我們使用“\d{3}-\d{2}-\d{4}”正則表達式匹配字符串中的社會安全號碼格式，并返回匹配對象。如果匹配成功，則輸出“Match found”，并輸出匹配到的內容。

2. 匹配字符集合

正則表達式中可以使用字符集合來匹配特定的字符范圍。例如，使用“[a-z]”可以匹配小寫字母，使用“[A-Z]”可以匹配大寫字母。下面是一些常見的字符集合用法：

- [...]：匹配字符集合中的任意一個字符

- [^...]：匹配除了字符集合中的任意一個字符以外的字符

- [a-z]：匹配指定范圍內的任意一個小寫字母

- [A-Z]：匹配指定范圍內的任意一個大寫字母

- [0-9]：匹配指定范圍內的任意一個數字字符

下面是一個簡單的示例：

```

import re

pattern=r'[aeiou]'

string='hello world'

matches=re.findall(pattern, string)

print(matches)

```

在上述代碼中，我們使用“[aeiou]”正則表達式匹配字符串中所有的元音字母，并返回所有匹配結果的列表。輸出結果中可以看到所有匹配的元音字母。

3. 匹配位置特定字符

正則表達式中還可以匹配一些與位置相關的特定字符，例如“^”表示字符串開頭，“$”表示字符串結尾，“\b” 表示單詞邊界，"\B"表示非單詞邊界。下面是一些常見的位置特定字符用法：

- ^：匹配字符串開頭

- $：匹配字符串結尾

- \b：匹配單詞邊界

- \B：匹配非單詞邊界

下面是一個簡單的示例：

```

import re

pattern=r'\bcat\b'

string1='The cat is sitting on the mat.'

string2='A black cat crossed the street.'

match1=re.search(pattern, string1)

match2=re.search(pattern, string2)

if match1:

print('Match found in string1:', match1.group())

else:

print('Match not found in string1')

if match2:

print('Match found in string2:', match2.group())

else:

print('Match not found in string2')

```

在上述代碼中，我們使用“\bcat\b”正則表達式匹配字符串中單詞“cat”的出現，并分別在兩個字符串中進行搜索操作。如果匹配成功，則輸出“Match found”，并輸出匹配到的內容。

需要注意的是，位置特定字符只匹配位置，而不匹配具體的字符。因此，在正則表達式中使用時，需要考慮這些字符所處的位置和周圍的字符。4. 分組匹配

正則表達式中可以使用括號對特定的內容進行分組，并在后續操作中引用這些分組。例如，使用“(ab)+”可以匹配一個或多個由“ab”組成的字符串。下面是一些常見的分組匹配用法：

- (...)：將括號內的內容作為一個分組

- (?:...)：將括號內的內容作為一個非捕獲分組

- \number：引用前面的第number個分組

下面是一個簡單的示例：

```

import re

pattern=r'(\d{3})-(\d{2})-(\d{4})'

string='My SSN is 123-45-6789'

match=re.search(pattern, string)

if match:

print('Match found:', match.group())

print('Group 1:', match.group(1))

print('Group 2:', match.group(2))

print('Group 3:', match.group(3))

else:

print('Match not found')

```

在上述代碼中，我們使用“(\d{3})-(\d{2})-(\d{4})”正則表達式匹配字符串中的社會安全號碼格式，并返回匹配對象。如果匹配成功，則輸出“Match found”，并輸出所有分組的內容。

需要注意的是，在分組匹配中，不僅可以用group()方法獲取整個匹配內容，還可以使用group(n)方法獲取每個分組的內容。

六、正則表達式應用場景

正則表達式在計算機科學和軟件工程領域中有著廣泛的應用，特別是在文本處理、數據提取和信息搜索等方面。下面介紹一些正則表達式的常見應用場景：

1. 數據清洗和格式化

在數據處理中，經常需要對數據進行清洗和格式化，以便進行后續的分析和處理。正則表達式可以方便地實現對數據的清洗和格式化操作，例如去除空格、提取數字和日期等。

2. 文本搜索和匹配

在文本處理中，經常需要進行搜索和匹配操作，以便找到特定的內容和信息。正則表達式可以方便地實現文本搜索和匹配操作，例如查找關鍵字、識別郵件地址和電話號碼等。

3. 數據提取和轉換

在數據處理中，經常需要從原始數據中提取特定的內容，并將其轉換為目標格式和結構。正則表達式可以方便地實現數據提取和轉換操作，例如從HTML頁面中提取鏈接和文本、格式化CSV文件和XML數據等。

4. 自然語言處理和機器學習

在自然語言處理和機器學習領域中，經常需要對文本內容進行分析、處理和分類。正則表達式可以方便地實現對文本內容的分析和處理操作，例如識別句子和單詞、進行文本分類和情感分析等。

七、總結

本文介紹了Python中的正則表達式相關知識，包括正則表達式基礎語法、匹配和搜索函數、正則表達式高級用法以及應用場景等。正則表達式是一種強大的文本處理工具，可以幫助我們更加高效地處理和分析數據。在實際應用中，需要根據具體情況選擇合適的正則表達式和函數，并注意正則表達式的性能和效率問題。

替換和分割

一、概述

在Python中，字符串是一種常見的數據類型，經常需要進行替換和分割操作。本文將詳細介紹Python中的字符串替換和分割相關知識，包括字符串替換函數、正則表達式替換、字符串分割函數以及應用場景等。

二、字符串替換

字符串替換是指將一個字符串中的某些內容替換為其他內容，常用于數據清洗、格式化和轉換等。Python中提供了多種字符串替換函數，可以方便地實現不同類型的替換操作。

1. replace()函數

replace()函數是Python中最基本的字符串替換函數，用于將一個字符串中的某個子串替換為另一個子串。其語法如下：

```

str.replace(old, new[, count])

```

其中，old代表要替換的子串，new表示替換后的新子串，count表示替換的次數（可選，默認全部替換）。調用該函數會返回一個新的字符串，原字符串不會被改變。

下面是一個簡單的示例：

```

string='hello world'

new_string=string.replace('world', 'python')

print(new_string)

```

在上述代碼中，我們使用replace()函數將字符串中的“world”替換為“python”，并輸出替換后的新字符串。

需要注意的是，replace()函數只會替換與old完全匹配的子串。如果要替換的子串在字符串中出現多次，需要使用count參數指定替換的次數。

2. translate()函數

translate()函數是Python中用于執行字符映射的函數，可以將字符串中的某些字符替換為其他字符。其語法如下：

```

str.translate(table[, deletechars])

```

其中，table表示字符映射表，deletechars表示要刪除的字符集合（可選）。調用該函數會返回一個新的字符串，原字符串不會被改變。

下面是一個簡單的示例：

```

string='hello world!'

table=str.maketrans('el', 'xy')

new_string=string.translate(table)

print(new_string)

```

在上述代碼中，我們使用translate()函數將字符串中的“e”和“l”分別替換為“x”和“y”，并輸出替換后的新字符串。

需要注意的是，translate()函數只能進行單個字符的替換操作，而且只會替換與映射表中相應位置上的字符相同的字符。

3. sub()函數

sub()函數是Python中用于正則表達式替換的函數，可以根據正則表達式將一個字符串中的某些內容替換為其他內容。其語法如下：

```

re.sub(pattern, repl, string[, count, flags])

```

其中，pattern代表正則表達式，repl代表替換后的新字符串，string表示要進行替換的字符串，count表示替換的次數（可選，默認全部替換），flags表示正則表達式的匹配模式（可選，默認為0）。調用該函數會返回一個新的字符串，原字符串不會被改變。

下面是一個簡單的示例：

```

import re

string='hello world!'

new_string=re.sub(r'world', 'python', string)

print(new_string)

```

在上述代碼中，我們使用sub()函數將字符串中的“world”替換為“python”，并輸出替換后的新字符串。需要注意的是，在使用正則表達式進行替換時，需要注意正則表達式的語法和規則，以及替換后的內容是否符合預期。

三、正則表達式替換

除了基本的字符串替換操作外，Python中還支持使用正則表達式進行字符串替換。正則表達式具有更加靈活和強大的文本處理能力，可以實現更加復雜的字符串替換操作。下面介紹一些常用的正則表達式替換函數和用法。

1. sub()函數

sub()函數是Python中用于正則表達式替換的函數，可以根據正則表達式將一個字符串中的某些內容替換為其他內容。其語法如下：

```

re.sub(pattern, repl, string[, count, flags])

```

使用正則表達式進行替換時，需要注意正則表達式的語法和規則，以及替換后的內容是否符合預期。下面是一個簡單的示例：

```

import re

string='hello world!'

new_string=re.sub(r'world', 'python', string)

print(new_string)

```

在上述代碼中，我們使用sub()函數將字符串中的“world”替換為“python”，并輸出替換后的新字符串。

2. subn()函數

subn()函數與sub()函數類似，也是用于正則表達式替換的函數，不同之處在于它返回一個包含替換結果和替換次數的元組。其語法如下：

```

re.subn(pattern, repl, string[, count, flags])

```

使用subn()函數時，需要注意返回值是一個元組，第一個元素為替換后的新字符串，第二個元素為替換的次數。下面是一個簡單的示例：

```

import re

string='hello world!'

new_string, count=re.subn(r'world', 'python', string)

print(new_string)

print(count)

```

在上述代碼中，我們使用subn()函數將字符串中的“world”替換為“python”，并輸出替換后的新字符串和替換的次數。

3. sub()函數中使用函數作為repl參數

在使用sub()函數進行正則表達式替換時，還可以使用函數作為repl參數，根據匹配結果進行自定義的替換操作。該函數接受一個匹配對象為參數，并返回一個新的字符串作為替換結果。下面是一個簡單的示例：

```

import re

def double(match):

return match.group(0) * 2

string='hello world!'

new_string=re.sub(r'o', double, string)

print(new_string)

```

在上述代碼中，我們使用sub()函數將字符串中的所有“o”替換為兩個“o”，并輸出替換后的新字符串。需要注意的是，在使用函數作為repl參數進行替換時，需要確保函數的返回值符合預期。

四、字符串分割

字符串分割是指將一個字符串按照特定的分隔符分成多個子串，常用于數據清洗、格式化和轉換等。Python中提供了多種字符串分割函數，可以方便地實現不同類型的分割操作。

1. split()函數

split()函數是Python中最基本的字符串分割函數，用于將一個字符串按照特定的分隔符分成多個子串。其語法如下：

```

str.split([sep[, maxsplit]])

```

其中，sep代表分隔符，maxsplit表示要進行分割的次數（可選，默認全部分割）。調用該函數會返回一個包含分割后子串的列表。

下面是一個簡單的示例：

```

string='hello world!'

substrings=string.split(' ')

print(substrings)

```

在上述代碼中，我們使用split()函數將字符串按照空格分割為兩個子串，并輸出子串列表。

需要注意的是，如果不指定分隔符，則默認以空格作為分隔符。如果要使用多個分隔符進行分割，則可以將多個分隔符放在一個字符串中，用“|”符號進行連接。

2. rsplit()函數

rsplit()函數與split()函數類似，也是用于字符串分割的函數，不同之處在于它從字符串的末尾開始分割。其語法如下：

```

str.rsplit([sep[, maxsplit]])

```

使用rsplit()函數時，需要注意分割方向與split()函數相反，即從右到左。

3. splitlines()函數

splitlines()函數用于按照行分隔符將一個字符串分成多行。其語法如下：

```

str.splitlines([keepends])

```

其中，keepends表示是否保留行分隔符（可選，默認為False）。調用該函數會返回一個包含分割后行的列表。

下面是一個簡單的示例：

```

string='hello\nworld!'

lines=string.splitlines()

print(lines)

```

在上述代碼中，我們使用splitlines()函數將字符串按照行分隔符分成兩行，并輸出行列表。

需要注意的是，在Windows系統中，行分隔符為“\r\n”，而在Unix/Linux系統中，行分隔符為“\n”。

4. partition()函數

partition()函數用于按照指定的分隔符將一個字符串分成三部分，分別是分隔符前的子串、分隔符本身和分隔符后的子串。其語法如下：

```

str.partition(sep)

```

調用該函數會返回一個包含三個元素的元組，分別為分隔符前子串、分隔符本身和分隔符后子串。

下面是一個簡單的示例：

```

string='hello world!'

partitions=string.partition(' ')

print(partitions)

```

在上述代碼中，我們使用partition()函數將字符串按照空格分成三部分，并輸出分割結果。

需要注意的是，如果分隔符不存在，則三個元素的值分別為原字符串、空字符串和空字符串。

5. rpartition()函數

rpartition()函數與partition()函數類似，也是用于字符串分割的函數，不同之處在于它從字符串的末尾開始分割。其語法如下：

```

str.rpartition(sep)

```

使用rpartition()函數時，需要注意分割方向與partition()函數相反，即從右到左。

五、應用場景

字符串替換和分割是Python中常用的文本處理操作，可以廣泛應用于數據清洗、格式化和轉換等場景。例如，在爬取網頁數據時，可能會遇到一些不規范或者重復的信息，這時就可以使用字符串替換函數進行清洗；在處理CSV文件時，需要將每行數據按照逗號分割成多個字段，這時就可以使用字符串分割函數進行轉換。

除此之外，字符串替換和分割還可以應用于文本搜索、統計、分析等方面，具有廣泛的應用價值。下面介紹一些常見的應用場景及其實現方法。

1. 數據清洗

數據清洗是指將一些不規范、重復或者無用的數據進行清理和處理，以提高數據的質量和可用性。在數據清洗過程中，常常需要使用字符串替換函數進行文本清洗。

例如，我們從網頁上爬取到一些商品信息，但是這些信息中包含了一些廣告語言，可以使用replace()函數將其替換為空格或者其他內容，以保證數據的準確性和可用性。

```

import requests

from bs4 import BeautifulSoup

url='https://www.example.com/products'

response=requests.get(url)

soup=BeautifulSoup(response.text, 'html.parser')

items=soup.select('.item')

for item in items:

title=item.find('h3').text.strip()

description=item.find('p').text.strip()

# 清洗數據

description=description.replace('廣告語言', '')

if len(description) > 50:

description=description[:50] + '...'

print(title, description)

```

在上述代碼中，我們使用replace()函數將商品描述中的廣告語言替換為空格，并截取前50個字符作為商品描述。

2. 數據轉換

數據轉換是指將一種數據格式轉換為另一種數據格式，以滿足特定的需求和要求。在數據轉換過程中，常常需要使用字符串分割函數進行字符串解析。

例如，在處理CSV文件時，每行數據以逗號分割成多個字段，可以使用split()函數將字符串按照逗號分割為一個列表，方便進行數據處理和分析。

```

import csv

with open('data.csv', 'r') as f:

reader=csv.reader(f)

for row in reader:

name, age, gender=row[0], int(row[1]), row[2]

# 處理數據

if age > 30:

print(name, age, gender)

```

在上述代碼中，我們使用csv模塊讀取CSV文件，并使用split()函數將每行數據按照逗號分隔成多個字段，然后根據條件篩選符合要求的數據并輸出。

3. 文本搜索

文本搜索是指在一個文本中查找指定的關鍵字或者模式，以尋找特定的信息。在文本搜索過程中，常常需要使用正則表達式進行模式匹配和字符串替換操作。

例如，在一個長文本中查找所有包含特定關鍵字的句子，可以使用re模塊進行正則表達式匹配和替換操作。

```

import re

text='Python is a powerful programming language. It is widely used in data science and web development.'

pattern=r'[A-Z][a-z]*\s+[a-z]*\s+(programming|language)'

matches=re.findall(pattern, text)

for match in matches:

sentence=re.sub(r'\b' + match + r'\b', '**' + match.upper() + '**', text)

print(sentence)

```

在上述代碼中，我們使用正則表達式匹配所有包含“programming”或者“language”的句子，并使用sub()函數將關鍵字加粗輸出。

總之，字符串替換和分割是Python中常用的文本處理操作，可以方便地實現數據清洗、格式化和轉換等功能，應用場景廣泛。在實際開發過程中，需要根據具體需求靈活選擇合適的函數和方法。六、常見問題

1. 字符串替換和分割函數的性能如何？

字符串替換和分割函數在處理小規模數據時，性能比較高，可以快速地完成操作。但是，隨著數據量的增大，其性能會逐漸下降，尤其是在使用正則表達式進行復雜匹配時。

為了提高性能，可以考慮使用Python中的其他文本處理庫，例如pandas、numpy等。這些庫提供了更高效的數據處理方法，可以大幅提升程序的性能。

2. 字符串替換和分割函數是否安全？

字符串替換和分割函數內部實現采用的是C或者底層語言編寫，存在一定的安全風險。在使用這些函數時，需要注意輸入參數和返回結果是否合法，避免因為不當輸入導致程序崩潰或者信息泄露等問題。

為了提高安全性，可以使用Python中的一些安全庫，例如cryptography等，對敏感數據進行加密和解密操作。

3. 字符串替換和分割函數如何處理中文字符？

在處理中文字符時，需要注意編碼方式和字符集的選擇，以保證正確的處理結果。在Python3中，默認采用Unicode編碼，支持多種字符集和語言。

如果出現亂碼等問題，可以使用encode()和decode()函數進行編碼和解碼操作，注意編碼方式的選擇。

七、總結

本文對Python中常用的字符串替換和分割函數進行了詳細介紹，包括replace()、re.sub()、split()、rsplit()、splitlines()、partition()和rpartition()等函數，以及應用場景和常見問題。掌握這些函數的使用方法和技巧，可以方便地進行文本處理和數據轉換，提高程序的效率和可靠性。

整合營銷服務商

通過python的正則表達式re模塊匹配出html標

過濾亂碼re.sub()

獲取<tr></tr>標簽之間內容

獲取超鏈接<a href=..></a>之間內容

獲取URL最后一個參數命名圖片或傳遞參數

爬取網頁中所有URL鏈接

爬取網頁標題title兩種方法

定位table位置并爬取屬性-屬性值

過濾<span></span>等標簽

獲取<script></script>等標簽內容

通過replace過濾<br />標簽

獲取<img ../>中超鏈接及過濾<img>標簽

正則表達式概述

匹配和搜索

替換和分割

更多精彩：「鏈接」

您的項目需求