Fork me on GitHub

Python爬虫学习之re库及正则表达式

正则表达式

regular expression 简称“RE”
正则表达式是用来简洁表达一组字符串的表达式。

‘PY’
‘PYY’
‘PYYYYY…’
正则表达式：
PY+

‘PY’开头，后续存在不多于10个字符，后续字符不能是‘P’或‘Y’
‘PYABC’ √
‘PYKXYZ’ ×
正则表达式：
PY[^PY]{0,10}

正则表达式：

1）通用的字符串表达框架
2）简洁表达一组字符串的表达式
3）针对字符串表达“简洁”和“特征”思想的工具
4）判断某字符串的特征归属

举例：

P(Y|YT|YTH|YTHO)?N
‘PN’、‘PYN’、’ PYTN’、‘PYTHN’、‘PYTHON’

PY[TH]ON
‘PYTON’、‘PYHON’

PY[^TH]?ON
‘PYON’、‘PYaON’、‘PYbON’、‘PYcON’…

PY{:3}N
‘PN’、‘PYN’、‘PYYN’、‘PYYYN’

^[A-Za-z]+$
由26个字母组成的字符串

^[A-Za-z0-9]+$
由26个字母和数字组成的字符串

^-?\d+$
整数形式字符串

[\u4e00-\u9fa5]
匹配中文字符

重点：

匹配IP地址的正则表达式

IP地址字符串形式的正则表达式
(IP地址分4段，每段0-255)
\d+.\d+.\d+.\d+
\d{1,3}.\d{1,3}.\d{1,3}.\d{1,3}

精确写法

0-99 : [1-9]?\d
100-199 : 1\d{2}
200-249 : 2[0-4]\d
250 255: 25[0-5]
(([1-9]?\d|1\d{2}|2[0-4]\d|25[0-5]).){3}([1-9]?\d|1\d{2}|2[0-4]\d|25[0-5])

 

Re库的基本使用

Re库是Python标准库

re库采用raw string类型表示正则表达式，表示为：r’text’
raw string 是不包含转义符的字符串

函数说明
re.search( ) 在一个字符串中搜索匹配正则表达式的第一个位置，返回match对象
re.match( ) 从一个字符串的开始位置起匹配正则表达式，返回match对象
re.findall( ) 搜索字符串，以列表类型返回全部能匹配的字串
re.split( ) 将一个字符串按照正则表达式匹配结果进行分割，返回列表类型
re.finditer( ) 搜索字符串，返回一个匹配结果的迭代类型，每个迭代元素是match对象
re.sub( ) 在一个字符串中替换所有匹配正则表达式的字串，返回替换后的字符串

re.search(pattern,string,flags=0)
pattern:正则表达式的字符串或原生字符串表示
string:待匹配字符串
falgs:
re.I 忽略正则表达式的大小写
re.M 正则表达式中的^操作符能够将给定字符串的每行当作匹配开始

re.S 正则表达式中的.操作符能够匹配所有字符，默认匹配除换行符外的所有字符

import re
match = re.search(r'[1-9]\d{5}' , 'BIT 100081')
if match:
print(match.group(0))
#输出100081

  • re.match(pattern,string,flags=0)
    pattern:正则表达式的字符串或原生字符串表示
    string:待匹配字符串
  • import re
  • match = re.match(r'[1-9]\d{5}' , '100081')
  • if match:
  •     print(match.group(0))
  • #输出100081
  • re.findall(pattern,string,flags=0)
    pattern:正则表达式的字符串或原生字符串表示
    string:待匹配字符串
  • import re
  • ls = re.findall(r'[1-9]\d{5}' , 'BIT100081 TSUI100086')
  • if ls:
  •     print(ls)
  • #输出['100081', '100086']
  • re.split(pattern,string,maxsplit=0,flags=0)
    将一个字符串按照正则表达式匹配结果进行分割，返回列表类型
    pattern:正则表达式的字符串或原生字符串表示
    string:待匹配字符串
    maxsplit:最大分割数，剩余部分作为最后一个元素输出
  • import re
  • ls = re.split(r'[1-9]\d{5}' , 'BIT100081 TSUI100086')
  • if ls:
  •     print(ls)
  • #输出['BIT', ' TSUI', '']
  • import re
  • ls = re.split(r'[1-9]\d{5}' , 'BIT100081 TSUI100086',maxsplit=1)
  • if ls:
  •     print(ls)
  • #输出['BIT', ' TSUI100086']，只匹配第一个
  • re.finditer(pattern,string,flag=0)
    搜索字符串，返回一个匹配结果的迭代类型，每个迭代元素是match对象
  • import re
  • for m in re.finditer(r'[1-9]\d{5}','BIT100081 TSUI100086'):
  •     if m:
  •         print(m.group(0))
  •  #输出
  • #100081
  • #100086
  • re.sub(pattern,repl,string,count=0,flag=0)
    在一个字符串中替换所有匹配正则表达式的子串，返回替换后的字符串
    repl:替换匹配字符串的字符串
    count:匹配的最大交换次数
  • import re
  • ls = re.sub(r'[1-9]\d{5}',':zipcode','BIT100081 TSU100084')
  • print(ls)
  • #输出BIT:zipcode TSU:zipcode
  • 面向对象用法：编译后多次操作
  • pat = re.compile(r'[1-9]\d{5}')
  • rst = pat.search('BIT 100081')

  • 正则表达式的贪婪匹配和最小匹配

    Re库默认采用贪婪匹配，即输出匹配最长的子串

  • >>>match = re.search(r'PY'.*N','PYANBNCNDN')
  • >>>match.group(0)
  • 'PYANBNCNDN'

  • 最小匹配

  • >>>match = re.search(r'PY'.*?N','PYANBNCNDN')
  • >>>match.group(0)
  • 'PYAN'

  • 最小匹配操作符

    *？前一个字符0次或无限次扩展，最小匹配
    +？ 前一个字符1次或无限次扩展，最小匹配
    ?? 前一个字符0次或1次扩展，最小匹配
    {m,n}? 扩展前一个字符m至n次（含n），最小匹配

实例：在东方财富网上爬取信息

import re

import requests

from bs4 import BeautifulSoup

import bs4

# 股票代码编号信息获取

def getHTMLText(url1):

    try:

        kv = {'user-agent': 'Mozilla/4.0'}

        r=requests.get(url1,headers=kv)

        # 设置浏览器的类型，进行迷惑

        r.raise_for_status()

        # 事先获得编码，提高爬虫速度

        r.encoding='utf-8'

        # 避免r.text错误的情况发生

        if r.text=='':

            getHTMLText(url1)

        else:

            return r.text

    except:

        getHTMLText(url1)

# 爬取所有股票的编号列表

def getStockList(demo):

    soup = BeautifulSoup(demo, 'html.parser')

    a = soup('a')

    for i in a:

        try:

            href= i.attrs['href']

            # 通过正则表达式来获得需要的部分

            str1=re.findall(r'[s][hz]\d{6}',href)

            # 排除不合格的href

            if str1!=[]:

                fllist.append(re.findall(r'[s][hz]\d{6}',href))

            else:

                continue

        except:

            continue

    return fllist

# 爬取单个股票的信息

def getStockInfo(demo2,output_file,stock):

    infolist = {}

    try:

        soup = BeautifulSoup(demo2, 'html.parser')

        stocklist=soup.find("div",class_="stock-bets")

        # 获取股票名称

        name=stocklist.find(class_='bets-name')

        infolist.update({'股票名称':name.text.split()[0]})

        # 获取股票其他信息

        for dl in stocklist.descendants:

            if isinstance(dl,bs4.element.Tag):

                key=dl.find('dt')

                value=dl.find('dd')

                # 排除当key为空值

                if key!=None:

                    infolist[key.string]=value.string

        # 将股票信息放入文件中

        with open(output_file,'a',encoding='utf-8') as f:

            f.write(str(infolist) + '\n')

    except:

        # 将爬取出错的股票信息打印放入到no_do列表中

        no_do.append(stock)

# 主函数

if __name__ == '__main__':

    count=1

    no_do=[]

    fllist=[]

    # 股票列表url

    stock_list_url='http://quote.eastmoney.com/stocklist.html'

    # 文件存放地址

    output_file = 'C:/Users/13156/Desktop/爬虫/Result_stock.txt'

    # 获取到股票列表 fllist

    demo=getHTMLText(stock_list_url)

    fllist=getStockList(demo)

    #对所有的股票进行迭代

    for i in range(len(fllist)):

        count+=1

        # 百度个股信息url

        stock_info_url = "https://gupiao.baidu.com/stock/{}.html".format(str(fllist[i])[2:-2])

        demo2=getHTMLText(stock_info_url)

        # 处理和打印个股信息

        getStockInfo(demo2,output_file,fllist[i])

        # 打印出进度条

        print('\r当前进度：{:.2f}%'.format(count*100 / len(fllist)),end='')

    # 打印出异常的信息

 

    print(no_do)

 
  • re.match(pattern,string,flags=0)
    pattern:正则表达式的字符串或原生字符串表示
    string:待匹配字符串
import re
match = re.match(r'[1-9]\d{5}' , '100081')
if match:
    print(match.group(0))
#输出100081
  • 1
  • 2
  • 3
  • 4
  • 5
  • re.findall(pattern,string,flags=0)
    pattern:正则表达式的字符串或原生字符串表示
    string:待匹配字符串
import re
ls = re.findall(r'[1-9]\d{5}' , 'BIT100081 TSUI100086')
if ls:
    print(ls)
#输出['100081', '100086']
  • 1
  • 2
  • 3
  • 4
  • 5
  • re.split(pattern,string,maxsplit=0,flags=0)
    将一个字符串按照正则表达式匹配结果进行分割，返回列表类型
    pattern:正则表达式的字符串或原生字符串表示
    string:待匹配字符串
    maxsplit:最大分割数，剩余部分作为最后一个元素输出
import re
ls = re.split(r'[1-9]\d{5}' , 'BIT100081 TSUI100086')
if ls:
    print(ls)
#输出['BIT', ' TSUI', '']
import re
ls = re.split(r'[1-9]\d{5}' , 'BIT100081 TSUI100086',maxsplit=1)
if ls:
    print(ls)
#输出['BIT', ' TSUI100086']，只匹配第一个
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • re.finditer(pattern,string,flag=0)
    搜索字符串，返回一个匹配结果的迭代类型，每个迭代元素是match对象
import re
for m in re.finditer(r'[1-9]\d{5}','BIT100081 TSUI100086'):
    if m:
        print(m.group(0))
 #输出
#100081
#100086
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • re.sub(pattern,repl,string,count=0,flag=0)
    在一个字符串中替换所有匹配正则表达式的子串，返回替换后的字符串
    repl:替换匹配字符串的字符串
    count:匹配的最大交换次数
import re
ls = re.sub(r'[1-9]\d{5}',':zipcode','BIT100081 TSU100084')
print(ls)
#输出BIT:zipcode TSU:zipcode
  • 1
  • 2
  • 3
  • 4

面向对象用法：编译后多次操作

pat = re.compile(r'[1-9]\d{5}')
rst = pat.search('BIT 100081')
  • 1
  • 2

regex = re.compile(pattern,flags=0)
将正则表达式的字符串形式编译成正则表达式对象

Re库的match对象

Match对象的属性

.string 待匹配的文本
.re匹配时使用的pattern对象（正则表达式）
.pos 正则表达式搜索文本的开始位置
.endpos 正则表达式搜索文本的结束位置

Match对象的方法

.group(0) 获得匹配后的字符串
.start() 匹配字符串在原始字符串的开始位置
.end() 匹配字符串在原始字符串的结束位置
.span()返回(.start(),end())

import re
m = re.search(r'[1-9]\d{5}','BIT 100081')
print(m.string)
print(m.re)
print(m.pos)
print(m.endpos)
print(m.group(0))
print(m.start())
print(m.end())
#输出结果
#BIT 100081
#re.compile('[1-9]\\d{5}')
#0
#10
#100081
#4
#10
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

正则表达式的贪婪匹配和最小匹配

Re库默认采用贪婪匹配，即输出匹配最长的子串

>>>match = re.search(r'PY'.*N','PYANBNCNDN')
>>>match.group(0)
'PYANBNCNDN'
  • 1
  • 2
  • 3

最小匹配

>>>match = re.search(r'PY'.*?N','PYANBNCNDN')
>>>match.group(0)
'PYAN'
posted @   慧眼识辰  阅读(303)  评论(0)  编辑  收藏  举报
相关博文：
· Python爬虫学习之Requests库
· MySQL学习基础篇Day6
· Python "爬虫"出发前的装备之一正则表达式
· 正则表达式
· Python_爬虫系列_3.Re(正则表达式)
阅读排行：
· 阿里最新开源QwQ-32B，效果媲美deepseek-r1满血版，部署成本又又又降低了！
· 开源Multi-agent AI智能体框架aevatar.ai，欢迎大家贡献代码
· Manus重磅发布：全球首款通用AI代理技术深度解析与实战指南
· 被坑几百块钱后，我竟然真的恢复了删除的微信聊天记录！
· AI技术革命，工作效率10个最佳AI工具
1
点击右上角即可分享
微信分享提示
AI IDE Trae