跟着嵩天老师学习爬虫三大模块笔记

request模块

HTTP协议方法	requests库方法	说明
GET	requests.get(url,params=None,**kwarges)	请求获取url位置的资源
HEAD	requests.head(url,**kwargs)	请求获取url位置资源的响应消息报告，即获得该资源的头部信息
POST	requests.post(url,data=None,json=None,**kwarges)	请求像URL位置的资源后附加新的数据
PUT	requests.put(url,data=None,**kwarges)	请求向url位置存储一个资源，覆盖原URL位置的资源
PATCH	requests.patch(url,data=Noen,**kwarges)	请求局部更新URL位置的资源，即改变该处资源的部分内容
DELETE	requests.delete(url,**kwarges)	请求删除URL位置存储的资源

六种方法是基于requests.request方法的：
requests.request(method,url,**kwarges)，其中包括13个访问控制参数：

params

data

json

headers

cookies

auth

filles

timeout

proxies

allow_redirects

stream

verify

cert

一般框架：

try:    r=requests.get(url,timeout=30)
    r.raise_for_status()
    r.encoding=r.apparent_encoding
except:
    return "产生异常"

正则表达式re模块

正则表达式

是对字符串操作的一种逻辑公式，就是用事先定义好的一些特定字符、及这些特定字符的组合，组成一个”规则字符串“，这个”规则字符串“用来表达对字符串的一种过滤逻辑

IP地址正规表达式：

（([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])

正则表达式的类型：

1.原生字符串类型raw string类型 r'表达式'

2.string类型

match对象

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

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

flags:正则表达式使用时得控制标记

函数	说明
re.search(pattern，string，flags=0)	在一个字符串中搜索匹配正则表达式的第一个位置，返回match对象
re.match(pattern，string，flags=0)	在一个字符串的 开始位置起匹配正则表达式，返回match对象
re.findall（pattern，string，flags=0）	搜索字符串，以列表类型返回全部能匹配的子串
re.split(pattern，string，maxsploit=0,flags=0)	将一个字符串按照正则表达式匹配结果进行分割，返回列表类型
re.finditer（pattern，string,flags=0）	搜索字符串，返回一个匹配结果的迭代类型，每个迭代元素是match对象
re,sub(pattern，repl,string,count=0,flags=0)	在一个字符串替换所有匹配正则表达式的子串，返回替代后的字符串
regx=re.compile(pattern,flags=0)	将正则表达式的字符串形式编译成正则表达式对象（个人理解就是相当于定义一个变量）

贪婪匹配（默认）

最小匹配

练习代码

import re
'''
match = re.search(r'[1-9]\d{5}', 'BIT 100081')
if match:
    print(match.group(0))#search函数得使用。返回match类型


match = re.match(r'[1-9]\d{5}', 'BIT 100081')
#这里match函数是从头开始匹配，所以输出为空，需要将字符串改为数字开头


ls = re.findall(r'[1-9]\d{5}','BIT100081 TSU100084')
print(ls)#返回列表类型


ls = re.split(r'[1-9]\d{5}', 'BIT100081 TSU100084')
print(ls)#split函数使用，输出去掉正则表达式得部分
print(re.split(r'[1-9]\d{5}', 'BIT100081 TSU100084', maxsplit=1))
#只匹配第一部分
'''
for m in re.finditer(r'[1-9]\d{5}', 'BIT100081 TSU100084'):
    if m:
        print(m.group(0))
#findiiter返回的是迭代类型，每个迭代类型又是一个match对象


ls = re.sub(r'[1-9]\d{5}', ':zipcode','BIT100081 TSU100084')
print(ls)#sub函数简单来说，就是替换匹配到的字符

淘宝爬虫实例

import requests
import re
#获取页面
def getHTMLText(url):
    try:
        header = {这里要写入你的头部信息}
        r = requests.get(url, headers=header)
        r.raise_for_status()
        r.encoding = r.apparent_encoding
        return r.text
    except:
        return ""


def parsePage(ilt,html):
    try:
        plt = re.findall(r'\"view_price\"\:\"[\d\.]*\"',html)
        tlt = re.findall(r'\"raw_title\"\:\".*?\"',html)#最小匹配
        for i in range(len(plt)):
            price = eval(plt[i].split(':')[1])
            title = eval(tlt[i].split(':')[1])
            ilt.append([price, title])
    except:
        print("")

def printGoodslist(ilt):
    tplt = "{:4}\t{:8}\t{:16}"
    print(tplt.format("序号","价格","商品名称"))
    count = 0
    for g in ilt:
        count = count + 1
        print(tplt.format(count, g[0],g[1]))


def main():
    goods = "书包"
    depth = 2
    start_url = 'http://s.taobao.com/search?q=' + goods
    infolist = []
    for i in range(depth):
        try:
            url = start_url + '&s=' + str(44*i)
            html = getHTMLText(url)
            parsePage(infolist,html)
        except:
            continue
    printGoodslist(infolist)

main()

beautiful soup模块

功能

简而言之，解析和提取 HTML/XML 数据。

五种基本元素：

基本元素	说明
Tag	标签是最基本的信息组织的单元，分别用<></>标明开头和结尾
Name	标签的名字，<p></p>的名字是p，格式：<tag>.name
attributes	标签的属性，字典形式组织（键和值），格式：<tag>.attrs
Navigablestring	标签内非属性字符串，格式:<tag>.string
comment	标签内字符串的注释部分

标签树的下行遍历：

属性	说明
.contens	子节点的列表，将<tag>所有儿子节点存入列表
.children	子节点的迭代类型，与.contens类似，用于循环遍历儿子节点
.descendants	子孙节点的迭代类型，包含所有子孙节点，用于循环遍历

标签树的上行遍历：

属性	说明
.parents	节点的父亲标签
.parents	节点先辈标签的迭代类型用于循环遍历先辈节点

标签树的平行遍历：

属性	说明
.next_sibling	返回按照HTML文本顺序的下一个平行节点的标签
.previous_sibling	返回按照HTML的文本顺序的上一个平行节点标签
.next_siblings	迭代类型，返回按照HTML文本顺序的后续所有平行节点的标签
.previous_siblings	迭代类型，返回按照HTML文本顺序的前续所有平行节点的标签

条件：平行遍历发生子啊同一个父亲节点下的各节点间

ps: Navigablestring也会构成标签树得节点，不能认为平行遍历到的下一个节点就是标签类型

实例

我将老师给的代码整合到一起，每句基本都会有注释，还没有学习python的小伙伴又不想看视频的话，把这些代码码一码也就差不多啦！ 要注意的是，这里基本都是输出语句，一定要慢慢体会，print一个语句运行以下，比较输出结果分析输出内容一步步来，学完一个知识块以后记得注释掉，再接着学下一个知识块，我这样学自我感觉棒棒哒~~~~下面这个就不要注释掉了喔

基本元素练习代码块

下行遍历练习代码块

上行遍历练习代码块

平行遍历练习代码块

这里还是把源代码放一下，不要copy不要只顾着看，码一码

import requests
from bs4 import BeautifulSoup
url="http://python123.io/ws/demo.html"
r = requests.get(url)
demo = r.text
soup = BeautifulSoup(demo , 'html.parser')  #html解释器


print(demo)
print(soup.prettify)#对比输出的不同，html解析的功能


#以下是五种基本元素的使用
tag = soup.a

print(tag)#输出a标签
print(tag.name) #输出标签的名字
print(tag.parent.name) #输出a的父类标签的名字

print(tag.attrs)#输出标签属性（输出方式为字典）
print(tag.attrs['class'])#输出['py1']，也就是属性class的值
print(tag.attrs['href'])#输出herf属性的值

print(type(tag.attrs)) #输出标签属性类型，这里是字典类型
print(type(tag))#输出标签的类型

print(tag.string)#输出a标签中的非属性字符串信息
print(soup.p.string)#输出p标签中的string
print(type(soup.p.string))#输出标签中的string的类型，是Navigablestring，有跨标签的性质所以p标签中的b标签并没有显示出来

newsoup = BeautifulSoup("<b><!--this is a comment--></b><p>this is not a moment</p>","html.parser")
#注释以<!--注释内容-->
print(newsoup)#并分析b标签和p标签的类型观察有什么不同


#标签数的下行遍历
tag = soup.body
print(tag)
print(tag.contents)#输出body标签的儿子节点，.contents返回的类型是列表
print(len(tag.contents))#返回儿子节点的数量,因为返回类型是列表类型所以可以用列表来检索标签内容
print(tag.contents[1])#输出列表第一个子节点
for child in tag.children:
    print(child)#遍历所有儿子节点
for child in tag.descendants:
    print(child)#遍历所有子孙节点


#标签树的上行遍历
tag = soup.title
print(tag.parent)#输出title标签的父亲
for parent in soup.a.parents:
    if parent is None:
        print(parent)
    else:
        print(print.name)#这里是遍历出a标签的所有父标签



#标签树的平行遍历
tag = soup.a
print(tag.next_sibling)#发现输出不是标签
print(tag.next_sibling.next_sibling)#a标签的下下个平行节点
print(tag.previous_sibling)#输出a标签的上一个平行节点
for sibling in tag.next_siblings:
    print(sibling)#遍历后续节点
for sibling in tag.previous_siblings:
    print(sibling)#遍历前续节点

中国大学排名

import requests
from bs4 import BeautifulSoup
import bs4

def getHTMLText(url):
    try:
        r = requests.get(url, timeout=30)
        r.raise_for_status()#值不为200时产生异常信息
        r.encoding = r.apparent_encoding
        return r.text

    except:
        return ""


def fillUnivList(ulist, html):#提取关键数据到列表中
    soup = BeautifulSoup(html,"html.parser")
    for tr in soup.find('tbody').children:
        if isinstance(tr, bs4.element.Tag):#检测tr标签类型是否为Tag类型（因为这里有可能时string类型）
            tds = tr('td')
            ulist.append([tds[0].string, tds[1].string, tds[3].string])


def printUnivList(ulist, num):#输出排名结果
    tplt = "{0:^12}\t{1:{3}^12}\t{2:^10}"
    print(tplt.format("排名", "学校名称", "总分", chr(12288)))
    for i in range(num):
        u = ulist[i]
        print(tplt.format(u[0], u[1], u[2], chr(12288)))


def main():
    uinfo = []
    url = 'http://www.zuihaodaxue.com/zuihaodaxuepaiming2016.html'
    html = getHTMLText(url)
    fillUnivList(uinfo, html)
    printUnivList(uinfo, 20)#20所学校相关信息

main()