问题1:为什么要登陆
  很多时候,在没有登录的情况下,我们可以访问一部分页面或请求一些接口,因为毕竟网站本身需要做SEO,不会对所有页面都设置登录限制。但是,不登录直接爬取会有一些弊端,弊端主要有以下两点。

  1. 设置了登录限制的页面无法爬取。如某论坛设置了登录才可查看资源,某博客设置了登录才可查看全文等,这些页面都需要登录账号才可以查看和爬取。

2.一些页面和接口虽然可以直接请求,但是请求一旦频繁,访问就容易被限制或者IP直接被封,但是登录之后就不会出现这样的问题,因此登录之后被反爬的可能性更低。登录账号可以降低被封禁的概率。

问题2:为什么要搭建cookies池
  我们可以尝试登录之后再做爬取,被封禁的几率会小很多,但是也不能完全排除被封禁的风险。如果一直用同一个账号频繁请求,那就有可能遇到请求过于频繁而封号的问题。如果需要做大规模抓取,我们就需要拥有很多账号,每次请求随机选取一个账号,这样就降低了单个账号的访问频率,被封的概率又会大大降低。

与IP代理池不同,Cookies池具有针对性,如果你爬微博就要构建一个微博cookies池,爬知乎就需要构建一个知乎cookies池;而IP代理池是通用的,可供不同的爬虫任务共同使用。

比如,当构建微博cookies池时,我们需要一些微博账号,然后使用selenium模拟登录微博,识别验证码,登录成功后,获取该账号对应的cookies,存入redis数据库,从而维护一个微博cookies池,一个账号对应一个cookies。当构建好cookies池后,我们就可以直接通过cookies进行登录,而不需要再模拟登录,包括输入账号密码,识别验证码等操作。

本篇博客中我们将使用redis,flask搭建一个可扩展的cookies池,这里我们将分别搭建微博和知乎的cookies池,之后任意站点的cookies池都可以通过类似的操作进行搭建,可以不断扩展,维护多个cookies池。

一、本节目标

我们以新浪微博为例来实现一个Cookies池的搭建过程。Cookies池中保存了许多新浪微博账号和登录后的Cookies信息,并且Cookies池还需要定时检测每个Cookies的有效性,如果某Cookies无效,那就删除该Cookies并模拟登录生成新的Cookies。同时Cookies池还需要一个非常重要的接口,即获取随机Cookies的接口,Cookies运行后,我们只需请求该接口,即可随机获得一个Cookies并用其爬取。

由此可见,Cookies池需要有自动生成Cookies、定时检测Cookies、提供随机Cookies等几大核心功能。

二、准备工作

搭建之前肯定需要一些微博的账号。需要安装好Redis数据库并使其正常运行。需要安装Python的RedisPy、requests、Selelnium、Flask库。另外,还需要安装Chrome浏览器并配置好ChromeDriver。

三、Cookies池架构

4个核心模块:

Cookies池架构的基本模块分为4块:存储模块、生成模块、检测模块、接口模块。每个模块的功能如下。

  • 存储模块负责存储每个账号的用户名密码以及每个账号对应的Cookies信息,同时还需要提供一些方法来实现方便的存取操作。

  • 生成模块负责生成新的Cookies。此模块会从存储模块逐个拿取账号的用户名和密码,然后模拟登录目标页面,判断登录成功,就将Cookies返回并交给存储模块存储。

  • 检测模块需要定时检测数据库中的Cookies。在这里我们需要设置一个检测链接,不同的站点检测链接不同,检测模块会逐个拿取账号对应的Cookies去请求链接,如果返回的状态是有效的,那么此Cookies没有失效,否则Cookies失效并移除。接下来等待生成模块重新生成即可。

  • 接口模块需要用API来提供对外服务的接口。由于可用的Cookies可能有多个,我们可以随机返回Cookies的接口,这样保证每个Cookies都有可能被取到。Cookies越多,每个Cookies被取到的概率就会越小,从而减少被封号的风险。

还有配置文件config,py和调度模块scheduler.py

以上设计Cookies池的的基本思路和前面讲的代理池有相似之处。接下来我们设计整体的架构,然后用代码实现该Cookies池。

四、Cookies池的实现

首先分别了解各个模块的实现过程。

配置模块

存储一些各个模块中需要使用的变量和参数配置config.py

# Redis数据库地址、端口、密码
REDIS_HOST =  "localhost"               # 注意本地就写字符串形式的"localhost"
REDIS_PORT = 6379
REDIS_PASSWORD =  None                  # 密码没有的话,就写None

# 产生器使用的浏览器
BROSER_TYPE = "chrome"                  # 注意浏览器类型,是字符串形式的

# 产生器类,如扩展其他站点,请在此配置
GENERATOR_MAP = {                       # 注意字典后的类名也是字符串形式的
    "weibo":"WeiboCookiesGenerator",
    "zhihu":"ZhihuCookiesGenerator"
}

# 测试类,如扩展其他站点,请在此配置
TESTER_MAP ={
    "weibo": "WeiboValidTester",
    "zhihu": "WeiboValidTester"
    # 'XXX':'XXXCookiesGenerator'
}

TESTER_URL_MAP = {
    'weibo': 'https://www.weibo.com',
    'zhihu': 'https://www.zhihu.com'
}

# 产生器和验证器循环周期
CYCLE = 120

# API地址和端口
API_HOST = '127.0.0.1'                  # host是字符串
API_PORT = 5000                         # port不是字符串

# 产生器开关,模拟登录添加Cookies
GENERATOR_PROCESS = True

# 验证器开关,循环检测数据库中Cookies是否可用,不可用删除
TESTER_PROCESS = True

# API接口服务
API_PROCESS = True

1. 存储模块

需要存储的内容包括账号信息与Cookies信息。

  • 账号由用户名和密码两部分组成,所以可以存成用户名和密码的映射。
  • Cookies可以存成JSON字符串,但是后面得需要根据账号来生成Cookies,需要知道哪些账号已经生成了Cookies,哪些没有生成,所以需要同时保存该Cookies对应的用户名信息,其实也是用户名和Cookies的映射

这里就是两组映射,Redis的Hash有天然的优势,所以这里我们就建立两个Hash。Hash的Key就是账号,Value对应着密码或者Cookies。

注意 : 由于Cookies池需要做到可扩展,存储的账号和Cookies不一定单单只有本例中的微博,其他站点同样可以对接此Cookies池,所以这里Hash的名称可以做二级分类。例如,存账号的Hash名称可以为accounts:weibo,存Cookies的Hash名称可以为cookies:weibo。如要扩展知乎的Cookies池,我们就可以使用accounts:zhihu和cookies:zhihu,这样比较方便。

接下来我们创建一个存储模块类,用以提供一些Hash的基本操作。有两个数据库,一个负责存储每个帐号的用户名和密码,另一个存储用户名和Cookies 信息。

db.py

import random
import redis
from CookiesPool.cookiespool.config import *  # 使用*的形式,就可以全部引入,不加config了

class ReidsClient:
    def __ini__(self,type,website,host=REDIS_HOST,port=REDIS_PORT,password=REDIS_PASSWORD):
        '''
        初始化Redis链接
        '''
        self.db = redis.StrictRedis(host=host,port=port,password=password,decode_responses=True)
        self.type = type
        self.website = website

    @property                                           # 设置成类属性,这样,后面使用就不用加()
    def name(self):
        '''
        获取表的名字
        '''
        return"{}:{}".format(self.type,self.website)

    def set(self,username,value):
        '''
        根据用户名设置键名和键值
        :param username: 用户名
        :param value: 密码或cookies
        :return:
        '''
        return self.db.hset(self.name,username,value)

    def get(self,username):
        """
        根据键名获取键值
        :param username: 用户名
        :return:
        """
        return self.db.hget(self.name,username)

    def delete(self,username):                                   # 注意,一定不要用del,会和内置的del冲突
        """
        根据键名删除键值对
        :param username: 用户名
        :return: 删除结果
        """
        return self.db.hdel(self.name,username)

    def username(self):
        """
        获取所有账户信息                                        # 在generator模块,会比较accounts和cookies用户名进而,accounts中有而cookies中没有的用户名,会用来模拟登陆,生成cookies
        :return: 所有用户名
        """
        return self.db.hkeys(self.name)

    def all(self):
        """
        获取所有键值对
        :return: 用户名和密码或Cookies的映射表
        """
        return self.db.hgetall(self.name)

    def count(self):
        """
        获取数目
        :return: 数目
        """
        return self.db.hlen(self.name)                          # 注意,使用的是hlen,没有hcount方法

    def random(self):
        """
        随机得到键值,用于随机Cookies获取
        :return: 随机Cookies
        """
        return random.choice(self.db.hvals(self.name))          # 注意是random.choice,不是random.random这是取0-1内的小数。



if __name__ == '__main__':
    conn = ReidsClient("acounts","weibo")
    result = conn.set('kvradspgbnqonhv-eow693@yahoo.com', 'Xdnxwovqp9')
    print(result)

(1)新建了一个RedisClient类,因为所有的账号和cookies是存储在redis中的,所以类名是RedisClient,之后对哈希表的操作,都是针对redis数据库的操作,所以要明白存储模块的类名为什么叫RedisClient;

(2)初始化init()方法里,首先初始化StrictRedis对象,建立Redis连接。然后有两个关键参数type和website,分别代表类型和站点名称,它们就是用来拼接Hash名称的两个字段。

(3)name()方法拼接了type和website,组成Hash的名称;如果这是存储账户的Hash,那么此处的type为accounts、website为weibo,如果是存储Cookies的Hash,那么此处的type为cookies、website为weibo。加@property设置成类属性,这样,后面方法使用就不用加()当做方法来使用了。

(4)set()、get()、delete()方法分别代表设置、获取、删除Hash的某一个键值对;

(5)username()方法,获取accounts或者cookies里的用户名信息。在generator模块,会比较accounts和cookies用户名accounts中有而cookies中没有的用户名,会用来模拟登陆,生成cookies。

(6)all()方法是取出cookies表里面的所有键值对,在tester的时候会将取出来的进行验证,是否有效;

(7)count()获取Hash的长度;

(8)random()方法比较重要,它主要用于从Hash里随机选取一个Cookies并返回。每调用一次random()方法,就会获得随机的Cookies,此方法与接口模块对接即可实现请求接口获取随机Cookies。取的hvals,所以不会取到用户名,在API模块随机获取cookies会用到。

2. 生成模块

生成模块负责获取各个账号信息并模拟登录,随后生成Cookies并保存。我们首先获取两个Hash的信息,看看账户的Hash比Cookies的Hash多了哪些还没有生成Cookies的账号,然后将剩余的账号遍历,再去生成Cookies即可。

generator.py

import json
from selenium import webdriver
from selenium.webdriver import DesiredCapabilities
from CookiesPool.cookiespool.config import *
from CookiesPool.cookiespool.db import RedisClient
from CookiesPool.weibologin.loginweibo import LoginWeibo
from CookiesPool.zhihulogin.loginzhihu import Zhihu


class CookiesGenerator(object):
    def __init__(self, website='default'):
        """
        父类, 初始化一些对象
        :param website: 名称
        :param browser: 浏览器, 若不使用浏览器则可设置为 None
        """
        self.website = website
        self.cookies_db = RedisClient('cookies', self.website)  # 存储用户名和cookies
        self.accounts_db = RedisClient('accounts', self.website)  # 存储用户名和密码
        self.init_browser()

    def __del__(self):
        self.close()

    def init_browser(self):
        """
        通过browser参数初始化全局浏览器供模拟登录使用
        :return:
        """
        # self.option = webdriver.ChromeOptions()
        # self.option.add_argument('headless')
        # self.browser = webdriver.Chrome(executable_path='F:BaiduNetdiskDownloadcookie_poolchromedriver',chrome_options=self.option)

        if BROWSER_TYPE == 'PhantomJS':
            caps = DesiredCapabilities.PHANTOMJS
            caps[
                "phantomjs.page.settings.userAgent"] = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/57.0.2987.133 Safari/537.36'
            self.browser = webdriver.PhantomJS(desired_capabilities=caps)
            self.browser.set_window_size(1400, 500)
        elif BROWSER_TYPE == 'Chrome':
            self.browser = webdriver.Chrome()

    def new_cookies(self, username, password):
        """
        新生成Cookies,子类需要重写
        :param username: 用户名
        :param password: 密码
        :return:
        """
        raise NotImplementedError

    def process_cookies(self, cookies):
        """
        处理Cookies
        :param cookies:
        :return:
        """
        dict = {}
        for cookie in cookies:
            dict[cookie['name']] = cookie['value']
        return dict

    def run(self):
        """
        运行, 得到所有账户, 然后顺次模拟登录
        :return:
        """
        accounts_usernames = self.accounts_db.usernames()
        cookies_usernames = self.cookies_db.usernames()

        for username in accounts_usernames:
            if not username in cookies_usernames:
                password = self.accounts_db.get(username)
                print('正在生成Cookies', '账号', username, '密码', password)
                result = self.new_cookies(username, password)
                # 成功获取
                if self.website == 'weibo':
                    if result.get('status') == 1:
                        cookies = self.process_cookies(result.get('content'))
                        print('成功获取到Cookies', cookies)
                        if self.cookies_db.set(username, json.dumps(cookies)):
                            print('成功保存Cookies')
                    # 密码错误,移除账号
                    elif result.get('status') == 2:
                        print(result.get('content'))
                        if self.accounts_db.delete(username):
                            print('成功删除账号')
                    else:
                        print(result.get('content'))
                        
                if self.website == 'zhihu':
                    if result.get('status') == 1:
                        cookies = result.get('content')
                        print('成功获取到Cookies', cookies)
                        if self.cookies_db.set(username, json.dumps(cookies)):
                            print('成功保存Cookies')
        else:
            print('所有账号都已经成功获取Cookies')

    def close(self):
        """
        关闭
        :return:
        """
        try:
            print('Closing Browser')
            self.browser.close()
            del self.browser
        except TypeError:
            print('Browser not opened')


class WeiboCookiesGenerator(CookiesGenerator):
    def __init__(self, website='weibo'):
        """
        初始化操作
        :param website: 站点名称
        :param browser: 使用的浏览器
        """
        CookiesGenerator.__init__(self, website)
        self.website = website

    def new_cookies(self, username, password):
        """
        生成Cookies
        :param username: 用户名
        :param password: 密码
        :return: 用户名和Cookies
        """
        return LoginWeibo(username, password, self.browser).login()


class ZhihuCookiesGenerator(CookiesGenerator):
    def __init__(self, website='zhihu'):
        """
        初始化操作
        :param website: 站点名称
        :param browser: 使用的浏览器
        """
        CookiesGenerator.__init__(self, website)
        self.website = website

    def new_cookies(self, username, password):
        """
        生成Cookies
        :param username: 用户名
        :param password: 密码
        :return: 用户名和Cookies
        """
        return Zhihu(username, password).login()


if __name__ == '__main__':
    generator = WeiboCookiesGenerator()
    generator.run()

逻辑:
(1)定义一个Generator类,初始化方法init()里面要实例化accounts和cookies的db,除此之外还有一个主脚本和new_cookies()

(2)主程序run()方法

  • 先调用2个db的username()方法,将它们各自的用户名取出来。然后通过if判断,将accounts中有,而cookies中没有的username查出来,然后调用new_cookies()生成cookies,因为每个网站对应的有自己的登录方式,所以在此将它们写到各自的子类中分别实现。
  • 模拟登陆完之后,会传递回来一个字典result,根据result中的status键的状态码来判断是否登陆成功。在生成模块里我们可以根据不同的状态码做不同的处理。

  • result.get(‘status’) ==1成功获取cookies,然后就result.get(‘content’)取出cookies进行加工,具体实现是将cookies中的name-value键值对重新赋值给字典,然后进行json.dum序列化。然后传递给db的set方法进行存储cookies;

  • result.get(‘status’) == 2就是失败了,账号h或密码错误,从accounts中将此账号的信息删除self.accounts_db.delete(username)

  • 如状态码为3的情况,则代表登录失败的一些错误,此时不能判断是否用户名或密码错误,也不能成功获取Cookies,那么简单提示再进行下一个处理即可。

result ={
    'status': 1,
    'content': cookies
}
if self.website == 'weibo':
    if result.get('status') == 1:
        cookies = self.process_cookies(result.get('content'))
        print('成功获取到Cookies', cookies)
        if self.cookies_db.set(username, json.dumps(cookies)):
            print('成功保存Cookies')
    # 密码错误,移除账号
    elif result.get('status') == 2:
        print(result.get('content'))
        if self.accounts_db.delete(username):
            print('成功删除账号')
    else:
        print(result.get('content'))

注意:字典中取某个键的值的方式 result.get(‘content’)

(3)如果要扩展其他站点,只需要实现new_cookies()方法即可。

代码运行之后就会遍历一次尚未生成Cookies的账号,模拟登录生成新的Cookies

chaojiying.py

import requests
from hashlib import md5
 
 
class Chaojiying(object):
 
    def __init__(self, username, password, soft_id):
        self.username = username
        self.password = md5(password.encode('utf-8')).hexdigest()
        self.soft_id = soft_id
        self.base_params = {
            'user': self.username,
            'pass2': self.password,
            'softid': self.soft_id,
        }
        self.headers = {
            'Connection': 'Keep-Alive',
            'User-Agent': 'Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 5.1; Trident/4.0)',
        }
        
 
    def post_pic(self, im, codetype):
        """
        im: 图片字节
        codetype: 题目类型 参考 http://www.chaojiying.com/price.html
        """
        params = {
            'codetype': codetype,
        }
        params.update(self.base_params)
        files = {'userfile': ('ccc.jpg', im)}
        r = requests.post('http://upload.chaojiying.net/Upload/Processing.php', data=params, files=files, headers=self.headers)
        return r.json()
 
    def report_error(self, im_id):
        """
        im_id:报错题目的图片ID
        """
        params = {
            'id': im_id,
        }
        params.update(self.base_params)
        r = requests.post('http://upload.chaojiying.net/Upload/ReportError.php', data=params, headers=self.headers)
        return r.json()

loginweibo.py:登录新浪微博,需要加一个获取Cookies的方法,并针对不同的情况返回不同的结果

import requests
from requests import RequestException
from selenium import webdriver
from selenium.common.exceptions import NoSuchElementException, TimeoutException
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from CookiesPool.chaojiying import Chaojiying
 
# 超级鹰用户名、密码、软件ID、
CHAOJIYING_USERNAME = ''
CHAOJIYING_PASSWORD = ''
CHAOJIYING_SOFT_ID = 
CHAOJIYING_KIND = 1902
 
class LoginWeibo():
    def __init__(self,username,password,browser):
        self.url = 'https://www.weibo.com'
        self.browser = browser
        self.wait = WebDriverWait(self.browser,20)
        self.username = username
        self.password = password
        self.chaojiying = Chaojiying(CHAOJIYING_USERNAME, CHAOJIYING_PASSWORD, CHAOJIYING_SOFT_ID)
 
    # def __del__(self):
    #     self.browser.close()
 
    def open(self):
        """
        打开网页输入用户名密码
        :return: None
        """
        self.browser.get(self.url)
        #找到用户名和密码输入框
        '''
        
        '''
        username = self.wait.until(EC.presence_of_element_located((By.ID,'loginname')))
        '''
        
        '''
        password = self.wait.until(EC.presence_of_element_located((By.NAME,'password')))
        #输入用户名和密码
        username.send_keys(self.username)
        password.send_keys(self.password)
 
    def get_click_button(self):
        '''
        找到登录按钮
        :return:
        '''
 
        '''
        登录
        '''
        button = self.wait.until(EC.element_to_be_clickable((By.CLASS_NAME,'W_btn_a')))
        return  button
 
    def login_successfully(self):
        """
        判断登陆是否成功
        :return:
        """
        '''
        登录成功才能看到
        I
        '''
        try:
            return bool(
                WebDriverWait(self.browser,5).until(EC.presence_of_element_located((By.CSS_SELECTOR,'.ficon_mail')))
            )
        except TimeoutException:
            return  False
 
    def get_click_image(self,name='captcha.png'):
        """
        获取验证码图片
        :param name:
        :return: 图片对象
        """
        try:
            '''
            
            '''
            element = self.wait.until(EC.presence_of_element_located((By.XPATH,'//img[@action-type="btn_change_verifycode"]')))
            image_url = element.get_attribute('src')
            image = get_html(image_url).content
            with open(name, 'wb') as f:
                f.write(image)
            return image
        except NoSuchElementException:
            print('')
        return  None
 
    def password_error(self):
        """
        判断是否密码错误
        :return:
        """
        try:
            element = WebDriverWait(self.browser, 5).until(
                EC.presence_of_element_located((By.XPATH, '//span[@node-type="text"]')))
            print(element.text)
            if element.text == '用户名或密码错误。查看帮助':
                return True
        except TimeoutException:
            return False
 
    def get_cookies(self):
        """
        获取Cookies
        :return:
        """
        print(self.browser.get_cookies())
        return self.browser.get_cookies()
 
    def login(self):
        #打开网址 输入用户名和密码
        self.open()
        # 点击登录按钮
        button = self.get_click_button()
        button.click()
        if self.password_error():
            print('用户名或密码错误')
            return {
                'status': 2,
                'content': '用户名或密码错误'
            }
        if self.login_successfully():
            print('登录成功')
            #获取帐号对应的cookies
            cookies = self.get_cookies()
            return {
                'status': 1,
                'content': cookies
            }
        else: #有时会需要验证码
            # 获取验证码图片
            image = self.get_click_image()
            # 识别验证码
            result = self.chaojiying.post_pic(image, CHAOJIYING_KIND)
            print(result)
            # 输入验证码
            verifycode = self.wait.until(EC.presence_of_element_located((By.NAME, 'verifycode')))
            verifycode.send_keys(result['pic_str'])
            # 点击登录按钮
            button = self.get_click_button()
            button.click()
            if self.login_successfully():
                print('登录成功')
                # 获取帐号对应的cookies
                cookies = self.get_cookies()
                return {
                    'status': 1,
                    'content': cookies
                }
            else:
                self.chaojiying.report_error(result['pic_id'])
                self.login()
                # return {
                #     'status': 3,
                #     'content': '登录失败'
                # }
 
def get_html(url):
    try:
        # 添加User-Agent,放在headers中,伪装成浏览器
        headers = {
            'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.100 Safari/537.36'
        }
        response = requests.get(url, headers=headers)
        if response.status_code == 200:
            response.encoding = response.apparent_encoding
            return response
        return None
    except RequestException:
        return None
 
if __name__ == '__main__':
    result = LoginWeibo('','',webdriver.Chrome()).login()

loginzhihu.py:使用requests模拟登录微博,登录成功后,获取帐号对应的cookies

import requests
import re
import execjs
import time
import hmac
from hashlib import sha1
 
 
class Zhihu(object):
 
    def __init__(self, username, password):
 
        self.username = username
        self.password = password
        self.session = requests.session()
        self.headers = {
            'content-type': 'application/x-www-form-urlencoded',
            'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.109 Safari/537.36',
            'x-zse-83': '3_1.1'
        }
 
    def login(self):
 
        # 请求login_url,udid_url,captcha_url加载所需要的cookie
        login_url = 'https://www.zhihu.com/signup?next=/'
        resp = self.session.get(login_url, headers=self.headers)
        print("请求{},响应状态码:{}".format(login_url, resp.status_code))
        # print(self.session.cookies.get_dict())
        # self.save_file('login',resp.text)
 
        udid_url = 'https://www.zhihu.com/udid'
        resp = self.session.post(udid_url, headers=self.headers)
        print("请求{},响应状态码:{}".format(udid_url, resp.status_code))
        # print(self.session.cookies.get_dict())
 
        captcha_url = 'https://www.zhihu.com/api/v3/oauth/captcha?lang=en'
        resp = self.session.get(captcha_url, headers=self.headers)
        print("请求{},响应状态码:{}".format(captcha_url, resp.status_code))
        # print(self.session.cookies.get_dict())
        # print(resp.text)
        # self.save_file('captcha',resp.text)
 
        # 校验是否需要验证吗,需要则直接退出,还没遇到过需要验证码的
        if re.search('true', resp.text):
            print('需要验证码')
            exit()
 
        # 获取signature参数
        self.time_str = str(int(time.time() * 1000))
        signature = self.get_signature()
        # print(signature)
 
        # 拼接需要加密的字符串
        string = "client_id=c3cef7c66a1843f8b3a9e6a1e3160e20&grant_type=password&timestamp={}&source=com.zhihu.web&signature={}&username={}&password={}&captcha=&lang=en&ref_source=homepage&utm_source=".format(
            self.time_str, signature, self.username, self.password)
        # print(string)
        # 加密字符串
        encrypt_string = self.encrypt(string)
        # print(encrypt_string)
 
        # post请求登陆接口
        post_url = "https://www.zhihu.com/api/v3/oauth/sign_in"
        resp = self.session.post(post_url, data=encrypt_string, headers=self.headers)
        print("请求{},响应状态码:{}".format(post_url, resp.status_code))
        print(self.session.cookies.get_dict())
        # print(resp.text)
        # self.save_file('post', resp.text)
 
        # 校验是否登陆成功
        if re.search('user_id', resp.text):
            print('登陆成功')
            return {
                'status': 1,
                'content': self.session.cookies.get_dict()
            }
        else:
            print("登陆失败")
            return {
                'status': 2,
                'content': "登陆失败"
            }
 
    def test(self):
 
        # 请求个人信息接口查看个人信息
        me_url = 'https://www.zhihu.com/api/v4/me'
        data = {
            'include': 'ad_type;available_message_types,default_notifications_count,follow_notifications_count,vote_thank_notifications_count,messages_count;draft_count;following_question_count;account_status,is_bind_phone,is_force_renamed,email,renamed_fullname;ad_type'
        }
        resp = self.session.get(me_url, data=data, headers=self.headers)
        print("请求{},响应状态码:{}".format(me_url, resp.status_code))
        print(resp.text)
        return resp.status_code
        # self.save_file('me',resp.text)
 
    def encrypt(self, string):
        with open('zhihu.js', 'r', encoding='utf-8') as f:
            js = f.read()
        result = execjs.compile(js).call('encrypt', string)
        return result
 
    def get_signature(self):
 
        h = hmac.new(key='d1b964811afb40118a12068ff74a12f4'.encode('utf-8'), digestmod=sha1)
        grant_type = 'password'
        client_id = 'c3cef7c66a1843f8b3a9e6a1e3160e20'
        source = 'com.zhihu.web'
        now = self.time_str
        h.update((grant_type + client_id + source + now).encode('utf-8'))
        return h.hexdigest()
 
    def save_file(self, name, html):
 
        with open('{}.html'.format(name), 'w', encoding='utf-8') as f:
            f.write(html)
 
 
if __name__ == "__main__":
    account = Zhihu('', '')
    account.login()
    account.test()

知识点:cookies
根据Netscape公司的规定,Cookie格式如下:

Set-Cookie: NAME=VALUE;Expires=DATE;Path=PATH;Domain=DOMAIN_NAME;SECURE

NAME=VALUE:
  这是每一个Cookie均必须有的部分。NAME是该Cookie的名称,VALUE是该Cookie的值。在字符串“NAME=VALUE”中,不含分号、逗号和空格等字符。

Expires=DATE:Expires
  变量是一个只写变量,它确定了Cookie有效终止日期。该属性值DATE必须以特定的格式来书写:星期几,DD-MM-YY HH:MM:SS GMT,GMT表示这是格林尼治时间。反之,不以这样的格式来书写,系统将无法识别。该变量可省,如果缺省时,则Cookie的属性值不会保存在用户的硬盘中,而仅仅保存在内存当中,Cookie文件将随着浏览器的关闭而自动消失。

Domain=DOMAIN-NAME:Domain
  该变量是一个只写变量,它确定了哪些Internet域中的Web服务器可读取浏览器所存取的Cookie,即只有来自这个域的页面才可以使用Cookie中的信息。这项设置是可选的,如果缺省时,设置Cookie的属性值为该Web服务器的域名。

Path=PATH:Path
  属性定义了Web服务器上哪些路径下的页面可获取服务器设置的Cookie。一般如果用户输入的URL中的路径部分从第一个字符开始包含Path属性所定义的字符串,浏览器就认为通过检查。如果Path属性的值为“/”,则Web服务器上所有的WWW资源均可读取该Cookie。同样该项设置是可选的,如果缺省时,则Path的属性值为Web服务器传给浏览器的资源的路径名。可以看出我们借助对Domain和Path两个变量的设置,即可有效地控制Cookie文件被访问的范围。

Secure:
在Cookie中标记该变量,表明只有当浏览器和Web Server之间的通信协议为加密认证协议时,浏览器才向服务器提交相应的Cookie。当前这种协议只有一种,即为HTTPS。

在模拟登陆成功后获得cookies,把cookies字典的name和value提取出来,重新赋值给dict字典,以便后续存储在redis的cookies_weibo中,存储的时候采用set方法,传入采用json.dumps()序列化之后的cookies

def process_cookies(self, cookies):
    dict = {}
    for cookie in cookies:
        dict[cookie['name']] = cookie['value']
    return dict

3. 检测模块

我们现在可以用生成模块来生成Cookies,但还是免不了Cookies失效的问题,例如时间太长导致Cookies失效,或者Cookies使用太频繁导致无法正常请求网页。如果遇到这样的Cookies,我们肯定不能让它继续保存在数据库里。
  所以我们还需要增加一个定时检测模块,它负责遍历池中的所有Cookies,同时设置好对应的检测链接,我们用一个个Cookies去请求这个链接。如果请求成功,或者状态码合法,那么该Cookies有效;如果请求失败,或者无法获取正常的数据,比如直接跳回登录页面或者跳到验证页面,那么此Cookies无效,我们需要将该Cookies从数据库中移除。
  此Cookies移除之后,刚才所说的生成模块就会检测到Cookies的Hash和账号的Hash相比少了此账号的Cookies,生成模块就会认为这个账号还没生成Cookies,那么就会用此账号重新登录,此账号的Cookies又被重新更新。

定时检测数据库中的Cookies 能否正常登录。检测模块需要做的就是检测Cookies失效,然后将其从数据中移除。tester.py:

import json
import re
import requests
from requests.exceptions import ConnectionError
from CookiesPool.cookiespool.db import *
from CookiesPool.cookiespool.config import *

class ValidTester:
    def __init__(self,website):
        self.website = website
        self.accounts_db = RedisClient("counts",self.website)
        self.cookies_db = RedisClient("cookies", self.website)

    def test(self,username,cookies):
        '''
        如果要求其子类一定要实现,不实现的时候会导致问题,那么采用raise的方式就很好。
        而此时产生的问题分类是NotImplementedError。
        :return:
        '''
        raise NotImplementedError

    def run(self):
        cookies_group =  self.cookies_db.all()
        for username,cookies in cookies_group.item():
            self.test(username,cookies)


class WeiboValidTester(ValidTester):

    def __init__(self,website="weibo"):                     # 指定website为微博
        ValidTester.__init__(self,website)
        # super().__init__(website)

    def test(self,username,cookies):
        print('正在测试Cookies', '用户名', username)
        try:
            cookies = json.loads(cookies)
        except:
            print('Cookies不合法', username)
            self.cookies_db.delete(username)
            print('删除Cookies', username)
            return
        try:
            url = TEST_URL_MAP[self.website]        # 从字典里面取出weibo等对应的url,注意取的时候用字典的形式
            response = requests.get(url=url,cookies=cookies,timeout=5,allow_redirects=False)
            if response.status_code == 200:
                html = response.text
                ret = re.findall("'islogin']='1'",html)
                if ret:
                    print('Cookies有效', username)
                else:
                    print('Cookies失效', username)
                    self.cookies_db.delete(username)
                    print('删除Cookies', username)
            else:
                print('Cookies失效', username)
                self.cookies_db.delete(username)
                print('删除Cookies', username)

        except ConnectionError as e:                # 那就是链接异常
            print('发生异常', e.args)


class ZhihuValidTester(ValidTester):

    def __init__(self,website="zhihu"):                     # 指定website为知乎
        ValidTester.__init__(self,website)
        # super().__init__(website)

    def test(self,username,cookies):
        print('正在测试Cookies', '用户名', username)
        try:
            cookies = json.loads(cookies)
        except:
            print('Cookies不合法', username)
            self.cookies_db.delete(username)
            print('删除Cookies', username)
            return
        try:
            url = TEST_URL_MAP[self.website]        # 从字典里面取出weibo等对应的url,注意取的时候用字典的形式
            response = requests.get(url=url,cookies=cookies,timeout=5,allow_redirects=False)
            if response.status_code == 200:
                html = response.text
                ret = re.findall("'islogin']='1'",html)
                if ret:
                    print('Cookies有效', username)
                else:
                    print('Cookies失效', username)
                    self.cookies_db.delete(username)
                    print('删除Cookies', username)
            else:
                print('Cookies失效', username)
                self.cookies_db.delete(username)
                print('删除Cookies', username)

        except ConnectionError as e:                # 那就是链接异常
            print('发生异常', e.args)

if __name__ == '__main__':
    WeiboValidTester().run()

代码解析:
(1)父类
  为了实现通用可扩展性,我们首先定义一个检测器的父类,声明一些通用组件,实现如下所示:

class ValidTester(object):
    def __init__(self, website='default'):
        self.website = website
        self.cookies_db = RedisClient('cookies', self.website)
        self.accounts_db = RedisClient('accounts', self.website)

    def test(self, username, cookies):
        raise NotImplementedError

    def run(self):
        cookies_groups = self.cookies_db.all()
        for username, cookies in cookies_groups.items():
            self.test(username, cookies)

在这里定义了一个父类叫作ValidTester,在init()方法里指定好站点的名称website,另外建立两个存储模块连接对象cookies_db和accounts_db,分别负责操作Cookies和accounts的Hash,run()方法是入口,在这里是遍历了所有的Cookies,然后调用test()方法进行测试,在这里test()方法是没有实现的,也就是说我们需要写一个子类来重写这个test()方法。

知识点1:****dic.items()

用于提取字典种的key和value值,并将key和它对应的value用元组包围起来,返回值的类型是 dict_items

dic = {'name': 'helen', 'age': 18, 'sex': 'women'}
li = list(dic.items())
print(li)                   # [('name', 'helen'), ('age', 18), ('sex', 'women')]

知识点2:
  Python编程中raise可以实现报出错误的功能,而报错的条件可以由程序员自己去定制。在面向对象编程中,可以先预留一个方法接口不实现,在其子类中实现。如果要求其子类一定要实现,不实现的时候会导致问题,那么采用raise的方式就很好。而此时产生的问题分类是NotImplementedError。

(2)子类
  每个子类负责各自不同网站的检测,如检测微博的就可以定义为WeiboValidTester,实现其独有的test()方法来检测微博的Cookies是否合法,然后做相应的处理,所以在这里我们还需要再加一个子类来继承这个ValidTester,重写其test()方法,实现如下:

import json
import requests
from requests.exceptions import ConnectionError

class WeiboValidTester(ValidTester):
    def __init__(self, website='weibo'):
        ValidTester.__init__(self, website)

    def test(self, username, cookies):
        print('正在测试Cookies', '用户名', username)
        try:
            cookies = json.loads(cookies)
        except TypeError:
            print('Cookies不合法', username)
            self.cookies_db.delete(username)
            print('删除Cookies', username)
            return
        try:
            test_url = TEST_URL_MAP[self.website]
            response = requests.get(test_url, cookies=cookies, timeout=5, allow_redirects=False)
            if response.status_code == 200:
                print('Cookies有效', username)
                print('部分测试结果', response.text[0:50])
            else:
                print(response.status_code, response.headers)
                print('Cookies失效', username)
                self.cookies_db.delete(username)
                print('删除Cookies', username)
        except ConnectionError as e:
            print('发生异常', e.args)

首先,在初始化时,继承父类的init(), 有如下2种方式

class Person(Animal):
    def __init__(self, name, hp, ad, sex):
        Animal.__init__(self, name, hp, ad)         # 执行父类方法,需要self
        super().__init__(name, hp, ad)            # 简写.效果同上。它不需要传参数Person,self。因为它本来就在类里面,自动获取参数
        self.sex = sex

然后,test()方法。
第一步:将Cookies转化为字典,检测Cookies的格式,如果格式不正确,直接将其删除。

json.loads()反序列化,读取。(和dumps相反,loads函数则是将json格式的数据解码,转换为Python字典)

import json

dic = [1,['a','b','c'],3,{'k1':'v1','k2':'v2'}]
ret = json.dumps(dic,ensure_ascii=False)    # 序列化时,不使用ascii码
res = json.loads(ret)                       # 反序列化
print(type(ret),ret)                        #  [1, ["a", "b", "c"], 3, {"k1": "v1", "k2": "v2"}]
print(type(res),res)                        #  [1, ['a', 'b', 'c'], 3, {'k1': 'v1', 'k2': 'v2'}]

第二步:1.如果格式没问题,那么就拿此Cookies使用requests模块请求被检测的URL。(检测的URL可以是某个Ajax接口,为了实现可配置化,我们将测试URL也定义成字典)。对微博来说,我们用Cookies去请求目标站点,同时禁止重定向和设置超时时间
    2.得到Response之后检测其返回状态码。如果直接返回200状态码,则Cookies有效,否则可能遇到了302跳转等情况,一般会跳转到登录页面,则Cookies已失效。如果Cookies失效,我们将其从Cookies的Hash里移除即可。状态码检测完成之后,还可以通过检测某个标志性的东西,是否存在于新页面。进一步做判断。

4. 接口模块

生成模块和检测模块如果定时运行就可以完成Cookies实时检测和更新。但是Cookies最终还是需要给爬虫来用,同时一个Cookies池可供多个爬虫使用,所以我们还需要定义一个Web接口,爬虫访问此接口便可以取到随机的Cookies。我们采用Flask来实现接口的搭建。提供对外服务的接口。api.py:

接口模块主要分成以下几部分:
1、导入flask,实例化一个Flask对象,在主程序中开启flask服务

from flask import Flask, g

__all__ = ['app']
app = Flask(__name__)

if __name__ == '__main__':
    app.run(host=API_HOST, port=API_PORT)

2、通过flask的g对象,使用反射,为flask设置属性,也就是链接redis实例化出我们的cookies_weibo数据库,方便后面调用set()、random()、counts()方法

def get_conn():

    for website in GENERATOR_MAP:
        print(website)
        if not hasattr(g, website):
            setattr(g, website + '_cookies', eval('RedisClient' + '("cookies", "' + website + '")'))
            setattr(g, website + '_accounts', eval('RedisClient' + '("accounts", "' + website + '")'))
    return g

3、通过flask的路由,建立几个视图函数。调用cookies_weibo数据库的set()、random()、counts()方法

完整代码

import json
from flask import Flask, g
from CookiesPool.cookiespool.config import *
from CookiesPool.cookiespool.db import *

__all__ = ['app']

app = Flask(__name__)


@app.route('/')
def index():
    return '

Welcome to Cookie Pool System

' def get_conn(): """ 获取 :return: """ for website in GENERATOR_MAP: print(website) if not hasattr(g, website): setattr(g, website + '_cookies', eval('RedisClient' + '("cookies", "' + website + '")')) setattr(g, website + '_accounts', eval('RedisClient' + '("accounts", "' + website + '")')) return g @app.route('//random') def random(website): """ 获取随机的Cookie, 访问地址如 /weibo/random :return: 随机Cookie """ g = get_conn() cookies = getattr(g, website + '_cookies').random() return cookies @app.route('//add//') def add(website, username, password): """ 添加用户, 访问地址如 /weibo/add/user/password :param website: 站点 :param username: 用户名 :param password: 密码 :return: """ g = get_conn() print(username, password) getattr(g, website + '_accounts').set(username, password) return json.dumps({'status': '1'}) @app.route('//count') def count(website): """ 获取Cookies总数 """ g = get_conn() count = getattr(g, website + '_cookies').count() return json.dumps({'status': '1', 'count': count}) if __name__ == '__main__': app.run(host=API_HOST, port=API_PORT)

我们同样需要实现通用的配置来对接不同的站点,所以接口链接的第一个字段定义为站点名称,第二个字段定义为获取的方法,例如,/weibo/random是获取微博的随机Cookies,/zhihu/random是获取知乎的随机Cookies。

知识点1:

from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello_world():
    return 'Hello World!'

if __name__ == '__main__':
    app.run(host='0.0.0.0',port=9000)
  • 第1行,引入Flask类,Flask类实现了一个WSGI应用
  • 第3行,app是Flask的实例,它接收包或者模块的名字作为参数,但一般都是传递name。让flask.helpers.get_root_path函数通过传入这个名字确定程序的根目录,以便获得静态文件和模板文件的目录。
  • 第5~7行,使用app.route装饰器会将URL和执行的视图函数的关系保存到app.url_map属性上。处理URL和视图函数的关系的程序就是路由,这里的视图函数就是hello_world。
  • 第9行,使用这个判断可以保证当其他文件引用这个文件的时候(例如“from hello import app”)不会执行这个判断内的代码,也就是不会执行app.run函数。
  • 第10行,执行app.run就可以启动服务了。默认Flask只监听虚拟机的本地127.0.0.1这个地址,端口为5000。 而我们对虚拟机做的端口转发端口是9000,所以需要制定host和port参数,0.0.0.0表示监听所有地址,这样就可以在本机访问了。 服务器启动后,会调用werkzeug.serving.run_simple进入轮询,默认使用单进程单线程的werkzeug.serving.BaseWSGIServer处理请求, 实际上还是使用标准库BaseHTTPServer.HTTPServer,通过select.select做0.5秒的“while TRUE”的事件轮询。 当我们访问“http://127.0.0.1:9000/”,通过app.url_map找到注册的“/”这个URL模式,就找到了对应的hello_world函数执行,返回“hello world!”,状态码为200。 如果访问一个不存在的路径,如访问“http://127.0.0.1:9000/a”,Flask找不到对应的模式,就会向浏览器返回“Not Found”,状态码为404”’

要想明白“@app.route()”的工作原理,先看一看Python中的装饰器(就是以“@”开头的)。理解了装饰器的概念,再继续来看路由:

什么是路由:处理URL和函数之间关系的程序。简单的说:路由就是将URL绑定到一个函数上面,这样浏览器客户端向web服务器发送一个URL请求后,服务器中的路由收到这个URL后,能立马找到对应的函数进行处理。

以下三个路由的例子:

@app.route('/')def index():
    pass 

@app.route('/')
def show_user(username):
    pass 

@app.route('/post/')
def show_post(post_id):
    pass
  • 第1个路由:捕获到 “/”,就进入函数进行处理,里面的函数叫做视图函数。URL从左到右第一个“/”为止一般是首页,因此第1一个路由是处理首页。
  • 第2个路由:捕获到 “/” ,其中尖括号 这一部分是动态可变的部分,其中不可以带有斜杠的。而且这个动态部分当做参数传递给了视图函数。
  • 第3个路由:捕获到 “/post/” 其中 “/post/”是静态部分,“”是动态部分,但是这个动态部分必须是个int类型的整数,同样其中不可以带有斜杠。同样这个动态部分也成为参数传入了视图函数show_post。这个rule是 的形式,而converter除了有int,还有float,path,string。

注意本例中add视图函数,传参规则

@app.route('//add//')
def add(website, username, password):
    """
    添加用户, 访问地址如 /weibo/add/user/password

    """
    g = get_conn()
    print(username, password)
    getattr(g, website + '_accounts').set(username, password)
    return json.dumps({'status': '1'})

还有一些需要注意的URL规则:

  • 1.如果路由中的URL规则是有斜杠结尾的,但是用户请求的时候URL结尾没有斜杠,则会自动将用户重定向到带有斜杠的页面。
  • 2.如果路由中的URL规则结尾不带斜杠的,但是用户请求时带了斜杠,那么就会返回404错误响应。
  • 3.还可以为同一个视图函数,定义多个URL规则:

这指定/users/将是第1页的URL,并且 /users/page/N将是第N页的URL

知识点2:
for 直接循环一个字典时,下面这种情形,出来的结果只有key,没有value

# 如果需要查询多个key,请使用for循环
dic = {'name': 'summer', 'age': 21}
for i in dic:
    print(i)

'''
执行输出:
age
Name
'''

知识点3:反射的应用

hasattr(obj, attr):
  这个方法用于检查obj是否有一个名为attr的值的属性,返回一个布尔值。
getattr(obj, attr):
  调用这个方法将返回obj中名为attr值的属性的值,例如如果attr为'bar',则返回obj.bar。
setattr(obj, attr, val):
  调用这个方法将给obj的名为attr的值的属性赋值为val。例如如果attr为'bar',则相当于obj.bar = val
delattr(obj, name)
  该函数删除该obj的一个由string指定的属性。delattr(x, 'foobar')=del x.foobar

在g对象中3次使用反射

# 检查g对象是否有
if not hasattr(g, website):


# 为g对象设置属性,实例化cookies_weibo这个db
setattr(g, website + "_cookies", eval('ReidsClient' + '("cookies",website)'))

# 在获取cookies_weibo这个对象的cookies没有使用常规的obj.random(),而是使用getattr()方法获得
cookies = getattr(g,website + "_cookies").random()    # 注意写法,g的website_weibo是g的一个属性,同时它也是一个对象,对象调用random()方法

知识点4:eval()的调用
  eval() 函数用来执行一个字符串表达式,并返回表达式的值。

setattr(g, "accounts_"+website,eval('ReidsClient' + '("accounts",website)'))

这里是想使用eval方法实例化一个accounts_weibo对象,ReidisClient是类,实例化时给init()初始化函数传参,也就是之前的type和website

注意:

  • eval函数里面是字符串,所以类名外面要加字符串形式;
  • 字符串形式的类名使用加号+拼接带字符串的括号;
  • 括号里面传参里面传参,如果是确定的字符串就传字符串形式的参数,如果是变量,就传变量,反正括号()外有引号包围,整体还是字符串;
  • website作为变量,以下2种形式等同,建议第一种;
website = "weibo"


arg1 = eval('("accounts",website)')
arg2 = eval('("accounts", "' + website + '")')

print(arg1,type(arg1))
print(arg2,type(arg2))


'''
结果输出:
('accounts', 'weibo') 
('accounts', 'weibo') 
'''

5. 调度模块

最后,我们再加一个调度模块让这几个模块配合运行起来,主要的工作就是驱动几个模块定时运行,同时各个模块需要在不同进程上运行。

思想:
1.定义一个Scheduler类。里面有一个run方法,是它的主脚本;除此之外还有3个方法generator、tester、api,将generator和tester的map字典进行遍历,同时利用eval()动态新建各个类的对象,调用其入口run()方法运行各个模块;

2.在run()主脚本里,先使用if判断在配置文件中是否开启执行generator、tester、api的开关。如果开启了,就在本模块里通过多进程的方式,使它们各自调用起来。

scheduler.py

import time
from  multiprocessing import Process                # 注意process和Process都有,要首字母大写的
from CookiesPool.cookiespool.api import app         # api模块只引入了app
from CookiesPool.cookiespool.config import *        # 其他模块是*
from CookiesPool.cookiespool.generator import *
from CookiesPool.cookiespool.tester import *


class Scheduler(object):
    @staticmethod
    def generate_cookie(cycle=CYCLE):
        while True:
            print('Cookies生成进程开始运行')
            try:
                for website, cls in GENERATOR_MAP.items():
                    generator = eval(cls + '(website="' + website + '")')
                    generator.run()
                    print('Cookies生成完成')
                    generator.close()
                    time.sleep(cycle)
            except Exception as e:
                print(e.args)

    @staticmethod
    def valid_cookie(cycle=CYCLE):
        while True:
            print('Cookies检测进程开始运行')
            try:
                for website, cls in TESTER_MAP.items():
                    tester = eval(cls + '(website="' + website + '")')
                    tester.run()
                    print('Cookies检测完成')
                    del tester
                    time.sleep(cycle)
            except Exception as e:
                print(e.args)


    @staticmethod
    def api():
        app.run(host=API_HOST, port=API_PORT)

    def run(self):

        if GENERATOR_PROCESS:                               # 等价于if GENERATOR_PROCESS == True:
            generate_process = Process(target=Scheduler.generate_cookie)
            generate_process.start()

        if VALID_PROCESS:
            valid_process = Process(target=Scheduler.valid_cookie)
            valid_process.start()

        if API_PROCESS:
            api_process = Process(target=Scheduler.api)
            api_process.start()



if __name__ == '__main__':
    scheduler = Scheduler()
    scheduler.run()

知识点1:进程
同时,各个模块的多进程使用了multiprocessing中的Process类,调用其start()方法即可启动各个进程。

p.start()
启动进程,并自动调用该子进程中的p.run()

p.run()
进程启动时运行的方法,正是它去调用target指定的函数,我们自定义类的类中一定要实现该方法

p.join([timeout])
主线程等待p终止(强调:是主线程处于等的状态,而p是处于运行的状态)。timeout是可选的超时时间,需要强调的是,p.join只能join住start开启的进程,而不能join住run开启的进程  

另外,注意target后跟的是函数名,不加括号

知识点2:eval的使用

  • 首先,for循环map里有哪些网站;
  • 然后,使用eval()实例化tester对象。因为cls是变量,所以没有加引号,后面跟着括号,里面放着参数,第一个website因为是固定的实例化时的变量,所以在括号内没有加引号,而第二个按理来说应该是一个字符串,但是例子中又是一个实实在在的变量,为了做区分,就加了两个引号,并且左右2个加号。
for website, cls in TESTER_MAP.items():
    tester = eval(cls + '(website="' + website + '")')
    tester.run()
    print('Cookies检测完成')
    del tester:

至此,我们的Cookies就全部完成了。

文章来源于互联网:Python爬虫 | cookie池

发表评论