1. 技术文章
  2. python爬虫入门（二）Opener和Requests

python爬虫入门（二）Opener和Requests

由 风流意气都作罢 提交于 2020-08-17 04:07:22

Handler和Opener

Handler处理器和自定义Opener

opener是urllib2.OpenerDirector的实例，我们之前一直在使用urlopen，它是一个特殊的opener(也就是我们构建好的)。

但是urlopen()方法不支持代理、cookie等其他的HTTP/GTTPS高级功能。所有要支持这些功能：

　　1.使用相关的Handler处理器来创建特定功能的处理器对象；

　　2.然后通过urllib2.build_opener()方法使用这些处理器对象，创建自定义opener对象；

　　3.使用自定义的opener对象，调用open()方法发送请求。

如果程序里所有的请求都使用自定义的opener,可以使用urllib2.install_open()将自定义的opener对象定义为全局opener,表示如果之后凡是调用urlopen,都将使用这个opener(根据自己的需求来选择)

简单的自定义opener()

复制代码 
# _*_ coding:utf-8 _*_
import urllib2

# 构建一个HTTPHandler处理器对象，支持处理HTTP的请求
http_handler = urllib2.HTTPHandler()
# 调用build_opener()方法构建一个自定义的opener对象，参数是构建的处理器对象
opener = urllib2.build_opener(http_handler)

request = urllib2.Request('http://www.baidu.com/s')
# 调用自定义opener对象的open()方法,发送request请求
response = opener.open(request) 


print response.read()
复制代码

debug log模式

可以在HTTPHandler里面加参数（debuglevel=1）打开

复制代码 
# _*_ coding:utf-8 _*_
import urllib2

# 构建一个HTTPHandler处理器对象，支持处理HTTP的请求
# http_handler = urllib2.HTTPHandler()
# 主要用于调试用
http_handler = urllib2.HTTPHandler(debuglevel=1)
# 调用build_opener()方法构建一个自定义的opener对象，参数是构建的处理器对象
opener = urllib2.build_opener(http_handler)

request = urllib2.Request('http://www.baidu.com/s')
response = opener.open(request)
# print response.read()
复制代码

ProxyHandler处理器（代理设置）

使用代理IP，这是爬虫/反爬虫的第二大招，通常也是最好用的。

很多网站会检测某一段时间某个IP的访问次数(通过流量统计，系统日志等)，如果访问次数多的不像正常人，它会禁止这个IP的访问。

所以我们可以设置一些代理服务器，每隔一段时间换一个代理，就算IP被禁止，依然可以换个IP继续爬取。

urllib2中通过ProxyHandler来设置使用代理服务器，使用自定义opener来使用代理：

免费代理网站：http://www.xicidaili.com/;https://www.kuaidaili.com/free/inha/

 

复制代码 
# _*_ coding:utf-8 _*_
import urllib2

# 构建一个Handler处理器对象，参数是一个字典类型，包括代理类型和代理服务器IP+Port
httpproxy_handler = urllib2.ProxyHandler({'http':'118.114.77.47:8080'})
#使用代理
opener = urllib2.build_opener(httpproxy_handler)
request = urllib2.Request('http://www.baidu.com/s')

#1 如果这么写，只有使用opener.open()方法发送请求才使用自定义的代理，而urlopen()则不使用自定义代理。
response = opener.open(request)

#12如果这么写，就是将opener应用到全局，之后所有的，不管是opener.open()还是urlopen() 发送请求，都将使用自定义代理。
#urllib2.install_opener(opener)
#response = urllib2.urlopen(request)

print response.read()
复制代码

 

但是，这些免费开放代理一般会有很多人都在使用，而且代理有寿命短，速度慢，匿名度不高，HTTP/HTTPS支持不稳定等缺点（免费没好货）,所以，专业爬虫工程师会使用高品质的私密代理

 私密代理

（代理服务器都有用户名和密码）必须先授权才能用

复制代码 
# _*_ coding:utf-8 _*_
import urllib2

#必须输入用户名密码，ip和port
authproxy_handler = urllib2.ProxyHandler({'http':'username:pwd@ip:port})
opener = urllib2.build_opener(authproxy_handler)
request = urllib2.Request('http://www.baidu.com/s')
response = opener.open(request)
print response.read()
复制代码

为了安全一般把私密代理ip用户名密码保存到系统环境变量里面，再读出来

复制代码 
# _*_ coding:utf-8 _*_
import urllib2
import os 

# 从环境变量里面取到用户名和密码
proxyuser = os.environ.get('proxuser')   
proxypasswd = os.environ.get('proxpasswd')
#必须输入用户名密码，ip和port
authproxy_handler = urllib2.ProxyHandler({'http':proxyuser+':'+proxypasswd+'@ip:port'})
opener = urllib2.build_opener(authproxy_handler)
request = urllib2.Request('http://www.baidu.com/s')
response = opener.open(request)
print response.read()
复制代码

 Cookielib库和HTTPCookieProcess处理器

 Cookie :是指某些网站服务器为了辨别用户身份和进行Session跟踪，而储存在用户浏览器上的文本文件，Cookie可以保持登录信息到用户下次与服务器的会话。

cookielib模块：主要作用是提供用于存储cookie的对象

HTTPCookieProcessor处理器：主要作用是处理这些cookie对象，并构建handler对象。

cookie库

该模块主要的对象有CookieJar、FileCookieJar、MozillaCookieJar、LWPCookieJar。

  • CookieJar：管理HTTP cookie值、存储HTTP请求生成的cookie、向传出的HTTP请求添加cookie的对象。整个cookie都存储在内存中，对CookieJar实例进行垃圾回收后cookie也将丢失。

  • FileCookieJar (filename,delayload=None,policy=None)：从CookieJar派生而来，用来创建FileCookieJar实例，检索cookie信息并将cookie存储到文件中。filename是存储cookie的文件名。delayload为True时支持延迟访问访问文件，即只有在需要时才读取文件或在文件中存储数据。

  • MozillaCookieJar (filename,delayload=None,policy=None)：从FileCookieJar派生而来，创建与Mozilla浏览器 cookies.txt兼容的FileCookieJar实例。

  • LWPCookieJar (filename,delayload=None,policy=None)：从FileCookieJar派生而来，创建与libwww-perl标准的 Set-Cookie3 文件格式兼容的FileCookieJar实例。

其实大多数情况下，我们只用CookieJar()，如果需要和本地文件交互，就用 MozillaCookjar() 或 LWPCookieJar()

下面通过实例登录人人网，学习cookieJar()用法

登录人人网

复制代码 
# _*_ coding:utf-8 _*_
import urllib2
import urllib
import cookielib

#通过CookieJar()类构建一个cookieJar对象，用来保存cookie的值
cookie = cookielib.CookieJar()
#通过HTTPCookieProcessor()处理器类构建一个处理器对象，用来处理cookie
#参数就是构建的CookieJar()对象
cookie_handler = urllib2.HTTPCookieProcessor(cookie)
#构建一个自定义的opener
opener = urllib2.build_opener(cookie_handler)
# 通过自定义opener的addheaders的参数，可以添加HTTP报头参数
opener.addheaders = [('User-Agent', 'Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/60.0.3112.101 Safari/537.36')]
#renren网的登录接口
url = 'http://www.renren.com/PLogin.do'
#需要登录的账号密码
data = {'email':'15********','password':'py********'}
# 通过urlencode()编码转换
data = urllib.urlencode(data)
# 第一次是POST请求，发送登录需要的参数，获取cookie
request = urllib2.Request(url,data = data)
response = opener.open(request)
print response.read()
复制代码

有了cookie之后，可以直接爬取其它页面

复制代码 
# _*_ coding:utf-8 _*_
import urllib2
import urllib
import cookielib

#通过CookieJar()类构建一个cookieJar对象，用来保存cookie的值
cookie = cookielib.CookieJar()
#通过HTTPCookieProcessor()处理器类构建一个处理器对象，用来处理cookie
#参数就是构建的CookieJar()对象
cookie_handler = urllib2.HTTPCookieProcessor(cookie)
#构建一个自定义的opener
opener = urllib2.build_opener(cookie_handler)
# 通过自定义opener的addheaders的参数，可以添加HTTP报头参数
opener.addheaders = [('User-Agent', 'Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/60.0.3112.101 Safari/537.36')]
#renren网的登录接口
url = 'http://www.renren.com/PLogin.do'
#需要登录的账号密码
data = {'email':'15********','password':'python********'}
# 通过urlencode()编码转换
data = urllib.urlencode(data)

request = urllib2.Request(url,data = data)
response = opener.open(request)
# print response.read()

# 可以直接爬取登录后的其它页面了
response_other = opener.open('http://friend.renren.com/managefriends')
print response_other.read()
复制代码

Requests模块

安装：直接pip install requests

Requests 继承了urllib2的所有特性。Requests支持HTTP连接保持和连接池，支持使用cookie保持会话，支持文件上传，支持自动确定响应内容的编码，支持国际化的 URL 和 POST 数据自动编码。

添加headers和查询参数

复制代码 
# _*_ coding:utf-8 _*_

import requests

kw = {'wd':'python'}
headers = {'User-Agent':'Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/60.0.3112.101 Safari/537.36'}

# params 接收一个字典或者字符串的查询参数，字典类型自动转换为url编码，不需要urlencode()
response = requests.get("http://www.baidu.com/s?", params = kw, headers = headers)

# 查看响应内容，response.text 返回的是Unicode格式的数据
print response.text

# 查看响应内容，response.content返回的字节流数据
print response.content

# 查看完整url地址
print response.url

# # 查看响应头部字符编码
print response.encoding

# 查看响应码
print response.status_code
复制代码

使用代理

复制代码 
# _*_ coding:utf-8 _*_

import requests

headers = {'User-Agent':'Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/60.0.3112.101 Safari/537.36'}
# 根据协议类型，选择不同的代理
proxies = {
  "http": "http://119.28.152.208:80",
}

response = requests.get("http://www.baidu.com/", proxies = proxies,headers=headers)
print response.text
复制代码

私密代理验证

urllib2 这里的做法比较复杂，requests只需要一步：

复制代码 
# _*_ coding:utf-8 _*_

import requests

headers = {'User-Agent':'Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/60.0.3112.101 Safari/537.36'}

proxy = { "http": "name:pwd@ip:port" }

response = requests.get("http://www.baidu.com/", proxies = proxy,headers=headers)

print response.text
复制代码

web客户端验证

复制代码 
import requests

auth=('test', '123456')

response = requests.get('http://192.168.xxx.xx', auth = auth)

print response.text
复制代码

session

在 requests 里，session对象是一个非常常用的对象，这个对象代表一次用户会话：从客户端浏览器连接服务器开始，到客户端浏览器与服务器断开。

会话能让我们在跨请求时候保持某些参数，比如在同一个 Session 实例发出的所有请求之间保持 cookie 。

登录人人网

复制代码 
# _*_ coding:utf-8 _*_

import requests

# 1. 创建session对象，可以保存Cookie值
ssion = requests.session()

# 2. 处理 headers
headers = {'User-Agent':'Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/60.0.3112.101 Safari/537.36'}

# 3. 需要登录的用户名和密码
data = {"email":"158xxxxxxxx", "password":"pythonxxxxxxx"}

# 4. 发送附带用户名和密码的请求，并获取登录后的Cookie值，保存在ssion里
ssion.post("http://www.renren.com/PLogin.do", data = data)

# 5. ssion包含用户登录后的Cookie值，可以直接访问那些登录后才可以访问的页面
response = ssion.get("http://zhibo.renren.com/news/108")

# 6. 打印响应内容
print response.text
复制代码

页面解析和数据处理

 爬虫一共就四个主要步骤：

  1. 明确目标 (要知道你准备在哪个范围或者网站去搜索)
  2. 爬 (将所有的网站的内容全部爬下来)
  3. 取 (去掉对我们没用处的数据)
  4. 处理数据（按照我们想要的方式存储和使用）

一般来讲对我们而言，需要抓取的是某个网站或者某个应用的内容，提取有用的价值。内容一般分为两部分，非结构化数据和结构化数据。

非结构化数据：先有数据，再有结构

结构化数据：先有结构，再有数据

1.非结构化的数据处理

复制代码 
1.文本、电话号码、邮箱地址  

　　　　-->正则表达式

2.HTML文件   

　　　　 -->正则表达式，XPath,CSS选择器
复制代码

2.结构化的数据处理

复制代码 
1.JSON文件 

　　　　-->JSON Path

　　　　-->转化成python类型进行操作

2.XML文件

　　　　-->转化成python类型（xmltodict）

　　　　-->XPath

　　　　-->CSS选择器

　　　　-->正则表达式
复制代码

正则表达式

简单回顾下python正则表达式的一些使用方法

正则表达式测试网站：http://tool.oschina.net/regex/#

re 模块的一般使用步骤如下：

  1. 使用 compile() 函数将正则表达式的字符串形式编译为一个 Pattern 对象

  2. 通过 Pattern 对象提供的一系列方法对文本进行匹配查找，获得匹配结果，一个 Match 对象。

  3. 最后使用 Match 对象提供的属性和方法获得信息，根据需要进行其他的操作
复制代码 
pattern = re.compile('\d')    #将正则表达式编译成一个pattern规则对象

pattern.match()    #从起始位置开始往后查找，返回第一个符合规则的，只匹配一次
pattern.search()   #从任意位置开始往后查找，返回第一个符合规则的，只匹配一次
pattern.findall()  #所有的全部匹配，返回列表
pattern.finditer() #所有的全部匹配，返回的是一个迭代器
pattern.split()    #分割字符串，返回列表
pattern.sub()      #替换
re.I   #表示忽略大小写
re.S   #表示全文匹配
复制代码

1.match()

复制代码 
import re

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

m = pattern.match('aaa123bbb456',3,5)   #可以指定match起始和结束的位置match（string,begin,end）
print m.group()     #12

m = pattern.match('aaa123bbb456',3,6)
print m.group()     #123
复制代码
复制代码 
import re
#匹配两组， re.I忽略大小写
pattern = re.compile(r"([a-z]+) ([a-z]+)",re.I)  #第一组（字母）和第二组（字母）之间以空格分开
m = pattern.match("Hello world and Python")

print m.group(0)     #Hello world    group(0)获取所有子串
print m.group(1)     #Hello          group(1)所有子串里面的第一个子串
print m.group(2)     #world          group(2)所有子串里面的第二个子串
复制代码

2.search()

复制代码 
import re

pattern = re.compile(r'\d+')
m = pattern.search('aaa123bbb456')
print m.group()    #123

m = pattern.search('aaa123bbb456',2,5)
print m.group()    #12
复制代码

3.findall()

复制代码 
import re

pattern = re.compile(r'\d+')
m = pattern.findall('hello 123456 789')   #
print m    #['123456', '789']

m = pattern.findall('hello 123456 789',5,10)
print m    #['1234']
复制代码

4.split()

复制代码 
# _*_ coding:utf-8 _*_

import re

pattern = re.compile(r'[\s\d\\\;]+')    #以空格，数字，'\'，'；'做分割

m = pattern.split(r'a b22b\cc;d33d   ee')

print m        #['a', 'b', 'b', 'cc', 'd', 'd', 'ee']
复制代码

5.sub()

复制代码 
# _*_ coding:utf-8 _*_

import re

pattern = re.compile(r'(\w+) (\w+)')
str = 'good 111,job 222'

m = pattern.sub('hello python',str)

print m    #hello python,hello python

m = pattern.sub(r"'\1':'\2'",str)

print m    #'good':'111','job':'222'
复制代码
复制代码 
# _*_ coding:utf-8 _*_

import re

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

m = pattern.sub('*',str)    #a*b*c*d*e*f*   把数字替换成'*'
print m
复制代码

内涵段子实例

 爬取贴吧所有内容，并通过正则表达式爬取出所有的段子

url变化

  • 第一页url: http: //www.neihan8.com/article/list_5_1 .html

  • 第二页url: http: //www.neihan8.com/article/list_5_2 .html

  • 第三页url: http: //www.neihan8.com/article/list_5_3 .html

 

pattern = re.compile('<dd\sclass="content">(.*?)</dd>', re.S)
每个段子内容都是在 <dd class='content'>......</dd>里面，通过正则可以获取内
复制代码 
#!/usr/bin/env python
# -*- coding:utf-8 -*-

import urllib2
import re


class Spider:
    def __init__(self):
        # 初始化起始页位置
        self.page = 1
        # 爬取开关，如果为True继续爬取
        self.switch = True

    def loadPage(self):
        """
            作用：下载页面
        """
        print "正在下载数据...."
        url = "http://www.neihan.net/index_" + str(self.page) + ".html"
        headers = {
            'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/60.0.3112.101 Safari/537.36'}
        request = urllib2.Request(url, headers = headers)
        response = urllib2.urlopen(request)

        # 获取每页的HTML源码字符串
        html = response.read()
        #print html

        # 创建正则表达式规则对象，匹配每页里的段子内容，re.S 表示匹配全部字符串内容
        pattern = re.compile('<dd\sclass="content">(.*?)</dd>', re.S)

        # 将正则匹配对象应用到html源码字符串里，返回这个页面里的所有段子的列表
        content_list = pattern.findall(html)

        # 调用dealPage() 处理段子里的杂七杂八
        self.dealPage(content_list)

    def dealPage(self, content_list):
        """
            处理每页的段子
            content_list : 每页的段子列表集合
        """
        for item in content_list:
            # 将集合里的每个段子按个处理，替换掉无用数据
            item = item.replace("<p>","").replace("</p>", "").replace("<br/>", "")
            # 处理完后调用writePage() 将每个段子写入文件内
            self.writePage(item)

    def writePage(self, item):
        """
            把每条段子逐个写入文件里
            item: 处理后的每条段子
        """
        # 写入文件内
        print "正在写入数据...."
        with open("tieba.txt", "a") as f:
            f.write(item)

    def startWork(self):
        """
            控制爬虫运行
        """
        # 循环执行，直到 self.switch == False
        while self.switch:
            # 用户确定爬取的次数
            self.loadPage()
            command = raw_input("如果继续爬取，请按回车（退出输入quit)")
            if command == "quit":
                # 如果停止爬取，则输入 quit
                self.switch = False
            # 每次循环，page页码自增1
            self.page += 1
        print "谢谢使用！"


if __name__ == "__main__":
    duanziSpider = Spider()
    duanziSpider.startWork()
复制代码

可以按回车接着爬取下一页内容,输入QUIT退出。

 爬取后的内容：

 

 

 

出处：https://www.cnblogs.com/derek1184405959/p/8449159.html

标签
KHTML
gecko
safari
Chrome
def
易学教程内所有资源均来自网络或用户发布的内容，如有违反法律规定的内容欢迎反馈！
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!