python(4): regular expression正则表达式/re库/爬虫基础

python 获取网络数据也很方便

抓取

requests 第三方库适合做中小型网络爬虫的开发, 大型的爬虫需要用到 scrapy 框架

解析

BeautifulSoup 库, re 模块

(一) requests 库

基本方法: requests.get() : 请求获取指定URL位置的资源, 对应http 协议的get方法

注意: 在抓取网页前要看一看这个网站是不是有爬虫协议,

如何看网站的爬虫协议? 有的网站会提供robots.txt

例如豆瓣的 www.douban.com/robots.txt

实例: 抓取豆瓣上小王子的一个书评

我们要抓取subject 目录, 从上述协议中看到它没有被禁止

抓取多个页面要注意他的延时, 这里是5s

import requests
r=requests.get('http://book.douban.com/subject/1084336/comments/')
print(r.status_code)  # 200 则说明一切正常
print(r.text) # 获取页面内容

除了上述r.text 解码, 还有r.content, r.json 等

上述抓取的数据有很多以下结构

<p class="comment-content">
<span class="short">痛苦迷茫不是因为成为了“可笑”的大人，而是成为大人却没有真正长大。所以回过头来想要从怀念童年中解脱缓解痛苦那是本末倒置的做法。如果你作为一个成年人觉得痛苦，原因不是因为你“成年”了，也不是因为是生而为“人”，而是“你”停止了思考停止了学习</p>

可以用beautifulsoup进行解析,  举例来看

from bs4 import BeautifulSoup
markup='<p class="title"><b>The Little Prince</b></p>'
soup=BeautifulSoup(markup,'lxml') # 对于html使用lxml解析器较好
# soup 的对象有四种: tag , navigablestring, beautifulsoup, comment
#tag就是标签, 类似</b>**</b> 对文字内容的修饰
#navigablestring就是tag 中的字符串, 比如这里的The Little Prince
#comment 是navigablestring的子类
print(soup.b) # 标签b的内容: <b>The Little Prince</b>
print(type(soup.b))  # <class 'bs4.element.Tag'>
# tag 也有两个属性 name ,attrs
tag=soup.p
print(tag.name) # p
print(tag.attrs) # {'class': ['title']}
print(tag.string) #  取到了tag中包含的非属性的字符串:The Little Prince
print(type(tag.string)) # <class 'bs4.element.NavigableString'>

soup.find_all('b')  # 找到所有b标签的内容
Out[24]: [<b>The Little Prince</b>]

小王子的解析

import requests
from bs4 import BeautifulSoup
r=requests.get('http://book.douban.com/subject/1084336/comments/')
soup=BeautifulSoup(r.text,'lxml') # 获得beautifulsoup 对象soup
pattern=soup.find_all('p','comment-content')
#评论的属性是标签p,属性是comment-content, 返回列表
 for item in pattern: print(item.string)

没有结果, 全是none!!  为啥??

(二)regular expression

正则表达式可以简化字符串, 'py','pyy','pyyy','pyyy....' 这些都可以用 正则表达式py+ 表示

常用表达式:

 补充: \D 表示非数字字符  {m,} 至少扩展m次,  {:m}扩展0-m次

\b  :匹配一个单词边界，也就是指单词和空格间的位置（即正则表达式的“匹配”有两种概念，一种是匹配字符，一种是匹配位置，这里的\b就是匹配位置的）。例如，“er\b”可以匹配“never”中的“er”，但不能匹配“verb”中的“er”。

\B :匹配非单词边界。“er\B”能匹配“verb”中的“er”，但不能匹配“never”中的“er”。

举例:

p(y|yt|yth|ytho)?n 表示: ?表示扩展0次或者1次, 表示为pn,pyn,pytn,pythn,python

python+ 表示: python ,pythonn,pythonnn,....

py[th]on  表示:pyton ,pyhon

py[^th]?on 表示:pyon,pyaon,pybon,....,其中排除 t h的字母进行0次或1次扩展

py{:3}on 表示pon  pyon pyyon pyyyon (扩展y 0 1 2 3次)

^[A-Za-z]+$ 匹配字符串开头和结尾 ,表示 由26个字母组成的字符串

^[A-Za-z0-9]+$ 匹配字符串开头和结尾, 表示 由26个字母和10个数字组成的字符串

^-?\d+$ 整数形式的字符串(可能是负数)

^[0-9]*[1-9][0-9]*$ 正整数形式的字符串

[1-9]\d{5} 中国境内邮政编码(6位数)

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

\d{3}-\d{8}   或者 \d{4}-\d{7} 表示国内电话号码: 010-62914227

举例: 匹配IP地址的正则表达式:

一个IP地址分为 四段,每段是0-255

\d+.\d+.\d+.\d+  这个没有限制位数 :+可以扩展1次或者无限次

\d{1,3}.\d{1,3}.\d{1,3}.\d{1,3}  这个有限制位数 每次是1 2 3位 ,但还是不精确 300.300.300.300也可以匹配

0-99表示为[0-9]?\d    100-199 表示为 1\d{2}    200-249 表示为2[0-4]\d   250-255 表示为25[0-5]

所示0-255由上面四段取| (或)得到,0-255表示为(([0-9]?\d |1\d{2}|2[0-4]\d|25[0-4]).){3}([0-9]?\d |1\d{2}|2[0-4]\d|25[0-4])

(二)re库介绍

re 是python的标准库,主要功能是用于字符串的匹配

import re 调用

正则表达式的表示类型:re库采用了raw string类型表示正则表达式,表示为r'text'

举例: r'[1-9]\d{5}'  大陆邮政编码

r'\d{3}-\d{8}|\d{4}-\d{7}' 国内电话号码

原生字符串与普通字符串不同在于 前面加一个r

区别在于原生字符串不包含转义符 \的 ,原生字符串中的\ 不解释为转义符

r'[1-9]\d{5}' 用普通字符串表示为:'[1-9]\\d{5}'  要用双斜杠\\

具体介绍上述函数:

(1) re.search(pattern, string, flags=0), pattern 表示正则表达式的字符串或者原生字符串

string表示待匹配字符串 ,flags表示一些控制标记

举例:

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

ans:
<_sre.SRE_Match object; span=(4, 10), match=''>
100081

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

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

ans:AttributeError: 'NoneType' object has no attribute 'group'

报错了,因为这个字符串的开头不匹配

若要对匹配结果进行使用,为了防止报错,增加if 判断

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

此时不会报错,但是也不会print 结果,因为匹配结果是空的!,以下正确!!可以匹配

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

(3)re.findall(pattern, string, flags=0) 返回列表类型

import re
ls=re.findall(r'[1-9]\d{5}','BIT 100081 XYT 100099')
if ls:
    print(ls)

ans:
['', '']

(4)re.split(pattern, string, maxsplit=0,flags=0) 返回列表类型,maxsplit最大分割数,超过它的作为一个整体最后再输出来.

import re
print(re.split(r'[0-9]\d{5}','BIT 100081 XYT 100099'))

ans:
['BIT ', ' XYT ', '']

上述将匹配的删除,增加maxsplit=1,结果是:

import re
print(re.split(r'[0-9]\d{5}','BIT 100081 XYT 100099',maxsplit=1))

ans:
['BIT ', ' XYT 100099']

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

import re
for m in re.finditer(r'[1-9]\d{5}','BIT 100081 XYT 100099'):
    if m:
        print(m.group(0))

ans:
100081
100099

100081
100099

(6)re.sub(pattern,repl, string,count=0,flags=0):替换所有匹配的字符串,并返回替换后的字符串

其中repl:表示替代匹配字符串的字符串(新的字符串)

count 表示匹配最大替换的次数

import re
subs=re.sub(r'[1-9]\d{5}',':zipcode','BIT 100081 XYT 100099')
print(subs)

ans:
BIT :zipcode XYT :zipcode

上述六个常用的归纳:

其中re.search()  re.match()  返回match对象, re.finditer()每个迭代元素是match对象

补充:re 的另一种等价用法

import re
rst1=re.search(r'[1-9]\d{5}','BIT 100081 XYT 100099')
print(rst1.group(0))

pat=re.compile(r'[1-9]\d{5}')#先进行编译,
rst2=pat.search('BIT 100089 XYT 100099')
print(rst2.group(0))

ans:
100081
100089

#re.compile可以将正则表达式的字符串形式编译成正则表达式对象

re.compile(pattern,flags=0)

(三)返回match对象 啥是match对象??

match对象的使用方法::

举例:

import re
m=re.search(r'[1-9]\d{5}','BIT 100081 XYT 100099')
print(m.string)
print(m.re)
print(m.pos)
print(m.endpos)
print(m.group(0))#只返回一次匹配结果,若要多次匹配结果则 用re.finditer()
print(m.start())
print(m.end())
print(m.span())

结果:

BIT 100081 XYT 100099
re.compile('[1-9]\\d{5}')  #说明了只有经过compile的才是真正的正则表达式
0
21
100081#返回第一个匹配结果
4 #匹配结果在原字符串中的起始位置
10
(4, 10)

(四)re的贪婪匹配

import re
#re默认采用贪婪匹配,即输出匹配最长的子串
m=re.search(r'py.*n','pyanbbncccn')
print(m.group())

#如何匹配最短的字符串? 最小匹配,加一个?就可以了
m1=re.search(r'py.?*n','pyanbbncccn')
print(m1.group())

ans:
pyanbbncccn
pyan