爬虫开发日记（第二天）

1.requests模块–发送POST请求

用法：
response = requests.post("http://www.baidu.com/", data = data, headers=headers)

data 的形式：字典

练习：使用POST请求爬取必应翻译

import json

import requests


class BingTransSpider(object):
    def __init__(self):
        self.url = 'https://cn.bing.com/ttranslatev3?isVertical=1&&IG=8D6B0AEE7D2A40039AD7518D7E20C1D3&IID=translator.5027.3'
        self.headers = {
            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/59.0.3071.86 Safari/537.36"}
        self.to_trans = input('选择需要翻译的语种 [1]英语 [2]中文: ')
        self.word = input('请输入需要翻译的单词:')

    def run(self):
        lang = 'en'
        if self.to_trans == "1":
            lang = "en"
        elif self.to_trans == "2":
            lang = 'zh-Hans'

        form_data = {
            "fromLang": "auto-detect",
            "to": lang,
            "text": self.word
        }

        response = requests.post(self.url, headers=self.headers, data=form_data)

        data = response.content.decode("utf-8")

        data_list = json.loads(data)

        print(data_list[0].get('translations')[0].get('text'))


if __name__ == '__main__':
    tool = BingTransSpider()
    tool.run()

运行结果如下：

选择需要翻译的语种 [1]英语 [2]中文: 1
请输入需要翻译的单词:中国
China

2.requests模块–含有cookie请求

爬虫中为什么要使用cookie

带上cookie的好处：

• 能够访问登录后的页面
• 正常的浏览器在请求服务器的时候肯定会带上cookie（第一次请求某个地址除外），所以对方服务器有可能会通过是否携带cookie来判断我们是否是一个爬虫，对应的能够起到一定的反爬的效果

带上cookie的坏处：

• 一套cookie往往对应的是一个用户的信息，请求太频繁有更大的可能性被对方识别为爬虫

使用方式

三种方式：

1. 直接复制cookie 添加到请求头headers中

2. 复制cookie, 使用关键字进行传参, requests.get(cookies=关键字参数)。
   格式: 字典

3. 使用代码进行登录, 然后获取到cookie，再携带cookie访问目标url

   1. 找到登录的网址url：

      (1) form表单, action=‘提交网址’, method=‘请求方式’ /input/select/area

      (2) Network --> url 和参数

   2. 拼接登录的参数

   3. 发送登录请求 POST

   4. 带着cookies请求目标url GET

      session = requests.session()

      session.post

      session.get

关于session类

requests模块提供了一个叫做session类，来实现客户端和服务端的会话保持

session = requests.session()
response = session.get(url, headers)

session实例在请求了一个网站后，对方服务器设置在本地的cookie会保存在session中，下一次再使用session请求对方服务器的时候，会带上前一次的cookie

练习：携带cookie爬取人人网

import requests


class RenRenSpider(object):
    def __init__(self):
        self.login_url = 'http://www.renren.com/PLogin.do'
        self.profile_url = 'http://www.renren.com/970956950/profile'
        self.headers = {
            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/59.0.3071.86 Safari/537.36"}

    def send_request(self, form_data):
        session = requests.session()
        session.post(self.login_url, headers=self.headers, data=form_data)
        response = session.get(self.profile_url, headers=self.headers)

        data = response.content.decode("utf-8")
        return data

    def save_data(self, data):
        with open('03renren.html', 'w') as f:
            f.write(data)

    def run(self):
        form_data = {
            'email': '******',
            'password': '*******',
        }
        data = self.send_request(form_data)

        self.save_data(data)


if __name__ == '__main__':
    tool = RenRenSpider()
    tool.run()

CookieJar对象转化Dict的方法

cookies = login_response.request._cookies # CookieJar对象

转换:

cookies_dict = requests.utils.dict_from_cookiejar(cookies) # 字典

---

SSL忽略认证

添加关键字参数: verify=False

---

使用代理

为什么要使用代理

让服务器以为不是同一个客户端在请求

防止我们的真实地址被泄露，防止被追究

原理:

正向代理和反向代理的区别：

反向代理：如 nginx, 代理对象是服务器

正向代理：如 VPN, 代理对象是客户端

代理IP的分类

根据代理服务器端的配置，向目标地址发送请求时，REMOTE_ADDR， HTTP_VIA，HTTP_X_FORWARDED_FOR三个变量不同而可以分为下面四类：

• 透明代理(Transparent Proxy)

REMOTE_ADDR = Proxy IP
HTTP_VIA = Proxy IP
HTTP_X_FORWARDED_FOR = Your IP

透明代理虽然可以直接“隐藏”你的IP地址， 但是通过HTTP_X_FORWARDED_FOR能查到你是谁。

• 匿名代理(Anonymous Proxy)

REMOTE_ADDR = proxy IP
HTTP_VIA = proxy IP
HTTP_X_FORWARDED_FOR = proxy IP

匿名代理比透明代理进步了一点：别人只能知道你用了代理，无法知道你是谁。

• 混淆代理(Distorting Proxies)

REMOTE_ADDR = Proxy IP
HTTP_VIA = Proxy IP
HTTP_X_FORWARDED_FOR = Random IP address

如上，与匿名代理相同，如果使用了混淆代理，别人还是能知道你在用代理，但是会得到一个假的IP地址，伪装的更逼真

• 高匿代理(Elite proxy或High Anonymity Proxy)

REMOTE_ADDR = Proxy IP
HTTP_VIA = not determined
HTTP_X_FORWARDED_FOR = not determined

可以看出来，高匿代理让别人根本无法发现你是在用代理，所以是最好的选择。

从使用的协议：代理ip可以分为http代理，https代理，socket代理等，使用的时候需要根据抓取网站的协议来选择

代理使用

免费IP {“协议”: “IP: port”}

付费IP {“协议”: “username:pwd@ip:port”}

proxy = {
    "http": "ip:port"
}

response = requests.get(url, headers=headers, proxies=proxy)

IP代理池

proxy_list = [
    {"协议":"ip:port"},
    {"":":"},
    ...
]

use_proxy = []
for proxy in proxy_list:
    try:
    	response = requests.get(url, headers=headers, proxies=proxy, timeout=3)  # 设置超时时间3秒
        # 过滤提取出能够使用的ip
        if response.status_code == 200:
            use_proxy.appende(proxy)
    except Exception as e:
        print(e)

注意点

反反爬

使用代理ip是非常必要的一种反反爬的方式，但是即使使用了代理ip，对方服务器任然会有很多的方式来检测我们是否是一个爬虫

比如：

一段时间内，检测IP访问的频率，访问太多频繁会屏蔽

检查Cookie，User-Agent，Referer等header参数，若没有则屏蔽

服务方购买所有代理提供商，加入到反爬虫数据库里，若检测是代理则屏蔽

所以更好的方式是购买质量更高的代理，或者自己搭建代理服务器，组装自己的代理IP池，同时在使用的时候使用随机的方式进行选择使用，不要每次都用一个代理ip，没事没有任何效果的

---

retrying模块

安装

pip install retrying

使用

添加装饰器: @retry(stop_max_attempt_number=)

import requests
from retrying import retry


class RetrySpider(object):
    def __init__(self):
        pass 
    
    # 请求3次, 如果3次都失败, 才抛出异常
    @retry(stop_max_attempt_number=3)
    def _send_request(self):
        url = 'http://www.baidu.connnn'
        response = requests.get(url)          
        raise response.status_code != 200
            
    def run(self):
        try:
			self._send_request()
		except Exception as e:
            print(e)

tool = RetrySpider()
tool.run()