Python爬虫

您所在的位置:网站首页 爬虫模拟登录成功后发现有的接口cookie信息不一样 Python爬虫

Python爬虫

2024-07-13 07:26:22| 来源: 网络整理| 查看: 265

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

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

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('[email protected]', '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:\BaiduNetdiskDownload\cookie_pool\chromedriver',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×tamp={}&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就全部完成了。



【本文地址】

公司简介

联系我们

今日新闻


点击排行

实验室常用的仪器、试剂和
说到实验室常用到的东西,主要就分为仪器、试剂和耗
不用再找了,全球10大实验
01、赛默飞世尔科技(热电)Thermo Fisher Scientif
三代水柜的量产巅峰T-72坦
作者:寞寒最近,西边闹腾挺大,本来小寞以为忙完这
通风柜跟实验室通风系统有
说到通风柜跟实验室通风,不少人都纠结二者到底是不
集消毒杀菌、烘干收纳为一
厨房是家里细菌较多的地方,潮湿的环境、没有完全密
实验室设备之全钢实验台如
全钢实验台是实验室家具中较为重要的家具之一,很多

推荐新闻


图片新闻

实验室药品柜的特性有哪些
实验室药品柜是实验室家具的重要组成部分之一,主要
小学科学实验中有哪些教学
计算机 计算器 一般 打孔器 打气筒 仪器车 显微镜
实验室各种仪器原理动图讲
1.紫外分光光谱UV分析原理:吸收紫外光能量,引起分
高中化学常见仪器及实验装
1、可加热仪器:2、计量仪器:(1)仪器A的名称:量
微生物操作主要设备和器具
今天盘点一下微生物操作主要设备和器具,别嫌我啰嗦
浅谈通风柜使用基本常识
 众所周知,通风柜功能中最主要的就是排气功能。在

专题文章

    CopyRight 2018-2019 实验室设备网 版权所有 win10的实时保护怎么永久关闭