初级爬虫第三天

主要内容：

• 付费IP的使用方式
• Auth认证
• cookie登录验证
• requests模块

 一、付费IP使用方式：

1.1 无论是免费IP还是付费IP，在使用之前，都需要测试一下，如果好使，再去使用IP爬取数据。

1.2 IP池：列表套字典

eg：[{"https": "IP1:端口1"}, {"http": "IP2: 端口2"}, {"https": "IP3: 端口3"}]

1.3 遍历IP池，利用遍历出来的IP创建IP处理器，再利用处理创建发送网络请求的opener对象

1.4 opener.open()中有一个参数timeout=x，即：x秒之后如果程序还没有反应，就算做超时，报超时，x默认为30

1.5 利用异常处理IP值不好用的报错或者超时

代码：

import urllib.request

爬取百度首页"https://www.baidu.com/"
def proxy_user():
    #1.目标网页URL
    url = "https://www.baidu.com/"
    #2. User-Agent
    user_agent = ["Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.121 Safari/537.36"]
    request = urllib.request.Request(url)
    request.add_header("User-Agent", user_agent[0])
    #3. 代理IP池
    #3.1 创建代理IP池
    #IP池结构是：列表套字典
    proxy_ip_list = [{"HTTP": "58.253.152.23:9999"}, {"HTTP": "112.87.68.242:9999"}, {"HTTP": "60.13.42.99:9999"}]
    #3.2 遍历IP
    for choose__proxy_ip in proxy_ip_list:
        #3.3 利用遍历出来的IP创建IP处理器
        proxy_ip_handler = urllib.request.ProxyHandler(choose__proxy_ip)
        #3.4 利用处理器创建opener对象
        opener = urllib.request.build_opener(proxy_ip_handler)
        #3.5 发送网络请求
        #利用异常处理+timeout参数，处理IP失效问题
        #如果IP使用异常，或者超过timeout设置时间，
        #则抛出异常，暂停使用当前IP，接着使用下一个IP
        try:
            #使用opener.open()发送网络请求，
            #超时参数timeout设置为10，超过10秒未响应，视为超时
            response = opener.open(request, timeout = 10)
        except Exception as e:
            #如果IP使用异常，或者超时，打印异常信息
            print(e)
            

34 proxy_user()

 

查看结果，发现当上一个IP不好用时，程序会自动使用下一个IP

2. 付费IP的两种写法：

2.1 写法1：发送付费的代理IP请求

（1）创建代理IP池

（2）创建handler处理器

（3）创建opener对象

（4）发送网络请求

注意：付费代理IP需要有：1. 购买时的用户名 2. 购买时的密码

代理IP池结构：列表套字典

其中字典结构：{"协议类型": "username: password@IP地址:端口号"}

import urllib.request

#付费代理IP第一种写法：
def money_proxy_user():
    #url = "http://www.baidu.com/"
    
    #1. IP池
    #结构：{"http/https": "username:pwd@IP:端口号"}
    money_proxy_list = [{"http": "abc:123@58.253.152.23:9999"}, 
                        {"http": "abc:123@112.87.68.242:9999"}, 
                        {"http": "abc:123@60.13.42.99:9999"}]
    #遍历IP
    for proxy_ip in money_proxy_list:
        #2. 创建代理IP处理器handler
        ProxyHandler = urllib.request.ProxyHandler(proxy_ip)
        #3. 创建opener对象
        opener = urllib.request.build_open(ProxyHandler)
        #4. 发送网络请求
        response = opener.open(url)                

2.2 付费IP第二种写法：使用密码管理器（推荐）

（1）创建IP池

（2）创建密码管理器

（3）向密码管理器中，添加用户名和密码

（4）创建处理器

（5）创建opener对象

（6）opener对象发送网络请求

import urllib.request

#付费代理IP第二种写法：
def money_proxy_user():
    url = "http://www.baidu.com/"
    
    #1. 创建IP池
    #结构：{"http/https": "IP值:端口号"}
    money_proxy_list = [{"http": "58.253.152.23:9999"}, 
                        {"http": "112.87.68.242:9999"}, 
                        {"http": "60.13.42.99:9999"}]
    #遍历IP
    for proxy_ip in money_proxy_list:
        #2. 创建密码管理器
        #密码管理器需要购买IP的用户名和密码
        user_name = "abc"
        password = "123"
        pass_word_manager = urllib.request.HTTPPasswordMgrWithDefaultRealm()
        #3. 向密码管理器添加用户名和密码
        pass_word_manager.add_password(None, proxy_ip, user_name, password)
        #4. 创建handler处理器
        money_proxy_handler = urllib.request.ProxyBasicAuthHandler(pass_word_manager)
        #5. 创建opener对象
        opener =urllib.request.build_opener(money_proxy_handler)
        #6. 发送请求
        response = opener.open(url)
        

注意：

1. 密码管理器对象，添加用户名和密码的方法：'

add_password(Realm, uri, user_name, password)

第一个参数realm是与远程服务器相关的域信息，一般没人管它都是写None

参数uri：填写代理IP！！！

user_name：付费IP用户名

password：付费IP密码

2. 本方式中，如果程序中提供的代理IP全部都不能使用，程序会使用本地IP

二、Auth认证：

使用范围：

（1）爬取公司内网数据

（2）通过第三方认证的方式（如：微信账号登录），进行爬取

方法：使用密码管理器

代码：

import urllib.request

def auth_user():
    #1. 给出内网账号和密码
    user_name = "abc"
    pwd = "123"
    #2. 内网的URL地址
    nei_url = "xxx"
    
    #3. 创建密码管理器
    pwd_manager = urllib.request.HTTPPasswordMgrWithDefaultRealm()
    #4. 向密码管理器中，添加用户名和密码
    #注意此时，add_password()的第二个参数要访问的目标网页URL地址
    pwd_manager.add_password(None, nei_url, user_name, pwd)
    
    #5. 创建处理器Handler
    auth_handler = urllib.request.HTTPBasicAuthHandler(pwd_manager)
    #6. 创建opener对象
    opener = urllib.request.build_opener(auth_handler)
    
    #7. 发送网络请求：
    response = opener.open(nei_url)

 

2.5：SSL爬虫报错：SSL: CERTIFICATE_VERIFY_FAILED

当使用urllib.request.urlopen()向https网页发送网络请求时，有时会报这个错误：

urllib2.URLError: <urlopen error [SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed (_ssl.c:581)

解决方法：导入ssl模块和如下代码，即可解决

import ssl

ssl._create_default_https_context = ssl._create_unverified_context

三、Cookie与登录信息：

目标：爬取药智网的会员中心页面数据

URL：https://www.yaozh.com/member/

目标网页截图：

3.1  第一次爬取：

import urllib.request
import ssl

#忽略SSL验证
 ssl._create_default_https_context = ssl._create_unverified_context

#1. 目标网页URL
url = "https://www.yaozh.com/member/"

#2. User-Agent
#2.1 创建request对象
request = urllib.request.Request(url)
#2.2 User-Agent池
user_agent_headers = ["Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.121 Safari/537.36"]
#2.3 向request对象添加User-Agent
request.add_header("User-Agent", user_agent_headers[0])

#也可以直接在创建request对象时，添加User-Agent
#request = urllib.request.Request(url, headers=user_agent_headers[0])


#3. 代理IP
#3.1 代理IP池
proxy_ip = {"https": "60.13.42.101:9999"}
#3.2 创建自定义处理器handler
proxy_handler = urllib.request.ProxyHandler(proxy_ip)
#3.3 创建自定义opener对象
opener = urllib.request.build_opener(proxy_handler)


#4. 发送网络请求
response = opener.open(request)

#5. 读取返回的数据
data = response.read().decode('utf-8')

#6. 数据持久化
with open("yaozh01.html", 'w', encoding='utf-8') as f:
    f.write(data)

得到结果：

结果，个人中心页面未登录

——（1）原因：登录需要账号信息：用户名和密码

但是，爬虫代码中，没有这两个信息

——（2）解决方法：向请求头中，添加cookie

因为，所有的个人信息，包括：账号和密码都保存在cookie中。

一旦用户登录成功，其账号和密码就会自动保存在cookie中。

而cookie位于请求头中。

——（3）所以，我们需要先登录成功一次，获取cookie，然后，将cookie添加到请求头中。这样，以后爬虫代码发送网络请求登录时，就可以自动使用第一次登陆成功后，保存下来的cookie，使用它里面的账号信息。

3.2 方式1：手动获取添加cookie：

（1）手动登录账号，进入个人中心页面

（2）f12，进入network，查看请求头request_headers

（3）如图所示，将cookie后面的所有信息全部复制粘贴，添加进请求头

（4）发送网络请求

import urllib.request
import ssl


#爬取药智网会员中心界面
#"https://www.yaozh.com/member/"

#忽略SSL验证
ssl._create_default_https_context = ssl._create_unverified_context

#1. 目标网页URL
url = "https://www.yaozh.com/member/"

#2. 请求头信息
#User-Agent、Cookie
#手动填写用户名和密码，进行登录，登陆成功之后，在会员中心页面，f12查看请求头信息，复制User-Agent和Cookie信息
user_agent = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.121 Safari/537.36",
              "Cookie": "acw_tc=2f624a1c15572983332095835e56ab374f19bbfa04320ed34624c8cb736211; PHPSESSID=db04icmo08qlth57e283e1jug6; Hm_lvt_65968db3ac154c3089d7f9a4cbb98c94=1557298333; MEIQIA_VISIT_ID=1KwMiirKV6lBEDTorlxXFpIQYZ2; MEIQIA_EXTRA_TRACK_ID=1KwMiirgbfupj7bs3kZzgBM0zWb; Hm_lpvt_65968db3ac154c3089d7f9a4cbb98c94=1557298612; yaozh_logintime=1557298624; yaozh_user=743973%09wtf1234; yaozh_userId=743973; db_w_auth=666998%09wtf1234; UtzD_f52b_saltkey=NQ3FQNjM; UtzD_f52b_lastvisit=1557295025; UtzD_f52b_lastact=1557298625%09uc.php%09; UtzD_f52b_auth=760dhxbJO6R21izVhpr2PAlqsjjpHEtuxu9QWpf%2FdzfvGFnBP6V66TEdhcVOWltYjPEmVh4tVSLLQTPKM12K%2BlK55Ls; yaozh_uidhas=1; yaozh_mylogin=1557298627; acw_tc=2f624a1c15572983332095835e56ab374f19bbfa04320ed34624c8cb736211; MEIQIA_VISIT_ID=1KwMiirKV6lBEDTorlxXFpIQYZ2; MEIQIA_EXTRA_TRACK_ID=1KwMiirgbfupj7bs3kZzgBM0zWb"
              }
#2.2 创建request对象,并添加User-Agent
request = urllib.request.Request(url, headers=user_agent)


#3. 代理IP
#3.1 代理IP，IP池
proxy_ip = {"https": "115.159.155.60:8118"}
#3.2 创建自定义处理器对象handler
proxy_handler = urllib.request.ProxyHandler(proxy_ip)
#3.3 创建自定义opener对象
opener = urllib.request.build_opener(proxy_handler)


#4. 发送网络请求，登录
response = opener.open(request)
#5. 读取返回数据
data = response.read().decode('utf-8')

#6. 数据持久化
with open("yaozhi02.html", "w", encoding='utf-8') as f:
    f.write(data)

 结果：

可以看到，在本机启动的网页会员中心，这次有了用户名，说明登录成功。

———手动获取cookie的缺点：（1）麻烦；（2）获取的cookie有时效性

3.3 方式2：使用代码自动获取cookie（重点）：

目标：自动获取（登陆后的）会员中心页面

难点：获取cookie，即：获取登录所需用户名和密码。由于在登录成功之后，Cookie会被自动保存，所以，要想获取Cookie，先要登录成功。

登录页面login和会员中心页面member是两个不同的页面，所以需要我们现在login页面登录成功，然后拿着cookie，去请求member页面

步骤：

（1）自动登录（但需要自己手动设置用户名和密码），登录成功之后，会自动保存Cookie

（2）代码自动获取Cookie

（3）带着cookie，代码请求会员中心页面，获取会员中心数据

———————————分割线—————————————————————

（1）为了能让程序自动登录，我们需要查看，登录过程中，浏览器都向服务器提交了哪些数据

由于登录过程为：

1. 浏览器向服务器提交登录数据
2. 服务器验证数据
3. 服务器向浏览器发送新的跳转页面的链接
4. 浏览器按照跳转页面的链接，向服务器重新发送请求

所以，在登录页面，点击“登录”按钮之后，页面会跳转到新的页面。此时浏览器network抓取到的数据，是第4步：浏览器向服务器按照跳转页面URL，向服务器发送请求时，的数据；而不是第1步：浏览器向服务器提交的登录数据。因为谷歌浏览器会只保留最新一次请求的数据，而将之前的请求抹除了。

所以，在f12的network中，点击preserve log按钮，这样浏览器就会保留之前发送过的请求日志。

点击preserve log按钮，在https://www.yaozh.com/login/操作登录，发现浏览器进行登录时，发送的是一个叫做“login”的网络请求。

点击login请求，发现：（1）login发送的是POST请求！！！；（2）Form Data：Form Data为需要发送POST请求时，要发送的参数

 

import urllib.request
import urllib.parse
import http.cookiejar
import ssl

#忽略SSL验证
ssl._create_default_https_context = ssl._create_unverified_context

#目标：爬取会员中心网页

#1. 会员登录，获取cookie
#1.1 登录网页URL
login_url = "https://www.yaozh.com/login/"

#1.2 请求头信息User-Agent
user_agent = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.121 Safari/537.36"}

#1.3 构造请求参数
#构造POST请求参数，格式必须是字典
#发现登录请求中，发送的是POST请求，POST请求有请求参数
#POST请求中需要用到的参数：位于浏览器请求头的Form Data中，将其中的数据全部复制下来
"""
username: wtf1234
pwd: 123456
formhash: 3210139E64
backurl: https%3A%2F%2Fwww.yaozh.com%2F
"""
login_request_data = {"username": "wtf1234",
                      "pwd": "123456",
                      "formhash": "3210139E64",
                      "backurl": "https%3A%2F%2Fwww.yaozh.com%2F"}


#1.4 转换POST请求参数格式
#POST请求中，上传的请求参数必须是2进制格式
login_request_data_bytes = urllib.parse.urlencode(login_request_data).encode("utf-8")

#1.5 向request对象中，添加URL地址、User-Agent、POST请求参数
#get请求中，参数拼接到URL地址中；POST请求中，Request对象里面专门有个data参数，用于接收POST请求参数
login_request = urllib.request.Request(login_url, headers=user_agent, data=login_request_data_bytes)

#1.6 构造CookieJar对象——用于保存管理cookie
my_cookiejar = http.cookiejar.CookieJar()

#1.7 构造自定义的可以添加cookie的处理器handler
#handler处理器的参数是构造的cookiejar对象
#因为urlopen()中不能添加cookie，所以我们需要找一个能添加cookie的处理器，然后再创建opener，再发送网络请求
cookie_handler = urllib.request.HTTPCookieProcessor(my_cookiejar)

#1.8 使用处理器handler对象，构造自定义opener对象
opener = urllib.request.build_opener(cookie_handler)

#1.9 使用opener对象，发送网络请求
#此时的login_request，既包含请求头信息，又包含请求参数
#此时，如果请求发送成功，则cookiejar对象会自动将cookie信息保存到opener对象中
opener.open(login_request)      #由于我们这里只是为了登录成功，获取cookie，所以不需要response对象接收返回数据


#2. 使用cookie，访问会员中心网页
#2.1 会员中心URL
member_url = "https://www.yaozh.com/member/"

#2.2 构造请求头，添加User-Agent信息
user_agent2 = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.121 Safari/537.36"}
member_request = urllib.request.Request(member_url, headers=user_agent2)

#2.3 拿着刚才获得的cookie，发送网络请求
#由于opener对象中已经保存有cookie信息，所以直接用opener对象发送网络请求即可
response = opener.open(member_request)

#3. 读取数据
data = response.read().decode("utf-8")

#4. 持久化
with open("yaozhi_day03.html", 'w', encoding='utf-8') as f:
    f.write(data)

 爬取结果：

注：目前为止学过的反爬机制：

（1）User-Agent：模拟真实用户

同一个浏览器，短时间内频繁访问，反爬

（2）IP地址：

同一个IP地址，短时间内频繁访问，反爬

（3）账号：

同一个账号，短时间内在不同地点（使用不同IP地址）访问，反爬

三、初学requests模块：

理论：

（1）requests模块为第三方模块

（2）使用方法：import requests     注意末尾多一个s

（3）优点：

• 简单易用
• URL会自动转译
• python2、python3的方法名字一样
• 有官方中文文档

import requests

#爬取百度首页"https://www.baidu.com/"

#1. 目标网页URL
url = "https://www.baidu.com/"

#2. 发送get请求
response = requests.get(url)
#返回的response为状态码

#3.解析数据
#3.1 方式1：使用content属性解析，返回的是2进制数据
data = response.content.decode('utf-8')

#3.2 方式2：使用text属性解析，返回的是字符串格式数据
str_data = response.text
#但是不建议，使用此种方式解析数据，因为text内部，将2进制数据转换为字符串格式，靠猜。