07 reptile related

九． Selenium与PhantomJS

1. Selenium

1）Selenium 可以根据我们的指令，让浏览器自动加载页面，获取需要的数据，甚至页面截屏，或者判断网站上某些动作是否发生。

2）Selenium 自己不带浏览器，不支持浏览器的功能，它需要与第三方浏览器结合在一起才能使用。

2. PhantomJS

1)  PhantomJS 是一个基于Webkit的“无界面”(headless)浏览器，它会把网站加载到内存并执行页面上的 JavaScript，因为不会展示图形界面，所以运行起来比完整的浏览器要高效。

2)      如果我们把 Selenium 和 PhantomJS 结合在一起，就可以运行一个非常强大的网络爬虫了，这个爬虫可以处理 JavaScrip、Cookie、headers，以及任何我们真实用户需要做的事情。

3.    快速入门

1） 导包

from selenium import webdriver
# 调用键盘按键操作时需要引入的Keys包
from selenium.webdriver.common.keys import Keys

2） 调用环境变量指定的PhantomJS浏览器创建浏览器对象

• driver = webdriver.PhantomJS()

3） 访问页面

• driver.get("http://www.baidu.com/")

4） 截图

• driver.save_screenshot("baidu.png")

5） 在百度搜索框写入文字

• driver.find_element_by_id("kw").send_keys(u"长城")

6）百度搜索按钮，click() 是模拟点击

• driver.find_element_by_id("su").click()

7）ctrl+a 全选输入框内容

• driver.find_element_by_id("kw").send_keys(Keys.CONTROL,‘a‘)

8）模拟Enter回车键

• driver.find _element_by_id("su").send_keys(Keys.RETURN)

9）页面前进和后退

• driver.forward()     #前进

• driver.back()        # 后退

10） 清除输入框内容

• driver.find_element_by_id("kw").clear()

11）关闭页面或关闭浏览器

• 关闭页面：driver.close()
• 关闭浏览器：driver.quit()

4.    selenium使用的注意点

1）获取文本和获取属性：先定位到元素，然后调用`.text`或者`get_attribute`方法来去

2）selenium获取的页面数据是浏览器中elements的内容

3）find_element和find_elements的区别

• find_element返回一个element，如果没有会报错
• find_elements返回一个列表，没有就是空列表
• 在判断是否有下一页的时候，使用find_elements来根据结果的列表长度来判断

4） 如果页面中含有iframe、frame，需要先调用driver.switch_to.frame的方法切换到frame中才能定位元素

5） selenium请求第一页的时候回等待页面加载完了之后在获取数据，但是在点击翻页之后，hi直接获取数据，此时可能会报错，因为数据还没有加载出来，需要time.sleep(3)

6）selenium中find_element_by_class_name智能接收一个class对应的一个值，不能传入多个

十．验证码识别

1. url不变，验证码不变

  请求验证码的地址，获得相应，识别

2. url不变，验证码会变

  思路：对方服务器返回验证码的时候，会和每个用户的信息和验证码进行一个对应，之后，在用户发送post请求的时候，会对比post请求中法的验证码和当前用户真正的存储在服务器端的验证码是否相同

1） 实例化session

2） 使用seesion请求登录页面，获取验证码的地址

3） 使用session请求验证码，识别

4） 使用session发送post请求’

3. 使用selenium登录，遇到验证码

 1）url不变，验证码不变，同上

 2）url不变，验证码会变

• selenium请求登录页面，同时拿到验证码的地址
• 获取登录页面中driver中的cookie，交给requests模块发送验证码的请求，识别
• 输入验证码，点击登录

import requests

kw = {‘wd‘:‘长城‘}
headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/54.0.2840.99 Safari/537.36"}

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

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

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

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

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

# 查看响应码
print (response.status_code)

import requests
 
formdata = {
    "type":"AUTO",
    "i":"i love python",
    "doctype":"json",
    "xmlVersion":"1.8",
    "keyfrom":"fanyi.web",
    "ue":"UTF-8",
    "action":"FY_BY_ENTER",
    "typoResult":"true"
}
 
url = "http://fanyi.youdao.com/translate?smartresult=dict&smartresult=rule&smartresult=ugc&sessionFrom=null"
 
headers={ "User-Agent": "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/51.0.2704.103 Safari/537.36"}
 
response = requests.post(url, data = formdata, headers = headers)
 
print (response.text)
 
#< span style="color: #008000"> 如果是json文件可以直接显示
print (response.json())

import requests

# 根据协议类型，选择不同的代理
proxies = {
  "http": "http://12.34.56.79:9527",
  "https": "http://12.34.56.79:9527",
}< br />
response = requests.get("http://www.baidu.com", proxies = proxies)
print response.text

import requests

response = requests.get("https://www.baidu.com/", verify=True)

# 也可以省略不写

# response = requests.get("https://www.baidu.com/")

print (r.text)

import urllib.r equest
import random
 
proxy_list = [
    {"http" : "124.88.67.81:80"},
    {"http" : "124.88.67.81:80"},
    {"http" : "124.88.67.81:80"},
    {"http" : "124.88.67.81:80"},
    {"http" : "124.88.67.81:80"}
]
 
# 随机选择一个代理
proxy = random.choice(proxy_list)
# 使用选择的代理构建代理处理器对象
httpproxy_handler = urllib.request.ProxyHandler(proxy)
 
open er = urllib.request.build_opener(httpproxy_handler)
 
request = urllib.request.Request("http://www.baidu.com/")
response = opener.open(request)
print (response.read())

# lxml_test.py
 
# 使用 lxml 的 etree 库
from lxml import etree
 
text = ‘‘‘

    

         
first item

         
second item

         
third item

         
fourth item

         
fifth item # 注意，此处缺少一个 
 闭合标签
     

 

‘‘‘
 
#利用etree.HTML，将字符串解析为HTML文档
html = etree.HTML(text)
 
# 按字符串序列化HTML文档
result = etree.tostring(html)
 
print(result)
 

<html>
    <body>
        <div>
       <ul>
             <li class="item-0"><a href="link1.html">first itema>li>
             <li class="item-1"><a href="link2.html">second itema>li>
             <li class="item-inactive"><a href="link3.html">third itema>li>
             <li class="item-1"><a href="link4.html">fourth itema>li>
             <li class="item-0"><a href="link5.html">fifth itema>li>
        ul>
         div>
    body>
html>    

 
<div>
    <ul>
         <li class="item-0"><a href="link1.html">first itema>li>
         <li class="item-1"><a href="link2.html">second itema>li>
         <li class="item-inactive"><a href="link3.html"><span class="bold">third itemspan>a>li>
         <li class="item-1"><a href="link4.html">fourth itema>li>
         <li class="item-0"><a href="link5.html">fifth itema>li>
     ul>
 div>

# lxml_parse.py
 
from lxml import etree
 
# 读取外部文件 hello.html
html = etree.parse(‘./hello.htm l‘)
result = etree.tostring(html, pretty_print=True)
 
print(result)

from lxml import etree
 
html = etree.parse(‘hello.html‘)
result = html.xpath(‘//li/@class‘)
 
print result

import json
 
strList = ‘[1, 2, 3, 4]‘
 
strDict = ‘{"city": "北京", "name": "大猫"}‘
 
json.loads(strList)
# [1, 2, 3, 4]
 
json.loads(strDict) # json数据自动按Unicode存储
# {u‘city‘: u‘北京‘, u‘name‘: u‘大猫‘}

import json
import chardet
 
listStr = [1, 2, 3, 4]
tupleStr = (1, 2, 3, 4)
dictStr = {"city": "北京", "name": "大刘"}
print json.dumps(dictStr, ensure_ascii=False)
# {"city": "北京", "name": "大刘"}

import json
 
listStr = [{"city": "北京"}, {"name": "大刘"}]
json.dump(listStr, open("listStr.json","w"), ensure_ascii=False)
 
dictStr = {"city": "北京", "name": "大刘"}
json.dump(dictStr, open("dictStr.json","w"), ensure_ascii=False)

# json_load.py
import json

strList = json.load(open("listStr.json"))
print strList

# [{u‘city‘: u‘北京‘}, {u‘name‘: u‘大刘‘}]
strDict = json.load(open("dictStr.json"))
print strDict

# {u‘city‘: u‘北京‘, u‘name‘: u‘大刘‘}

# coding=utf-8
import requests
from lxml import etree
import json
from queue import Queue
import threading
 
class Qiubai:

    def __init__(self):
        self.headers = {
            "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_5) AppleWeb            Kit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.36"}
        self.url_queue = Queue()   #实例化三个队列，用来存放内容
        self.html_queue =Queue()
        self.content_queue = Queue()
 
    def get_total_url(self):
        ‘‘‘
        获取了所有的页面url，并且返回urllist
        return ：list
        ‘‘‘
        url_temp = ‘https://www.qiushibaike.com/8hr/page/{}/‘
        url_list = []
        for i in ran ge(1,36):
            self.url_queue.put(url_temp.format(i))
 
    def parse_url(self):
        ‘‘‘
        一个发送请求，获取响应，同时etree处理html
        ‘‘‘
        while self.url_queue.not_empty:
            url = self.url_queue.get()
            print("parsing url:",url)
            response = requests.get(url,headers=self.headers,timeout=10) #发送请求
            html = response .content.decode() #获取html字符串
            html = etree.HTML(html) #获取element 类型的html
            self.html_queue.put(html)
            self.url_queue.task_done()

    def get_content(self):
        ‘‘‘
        :param url:
        :return: 一个list，包含一个url对应页面的所有段子的所有内容的列表
        ‘‘‘
        while self.html_queue.not_empty:
            html = self.html_queue.get()
            total_div = html.xpath(‘//div[@ class="article block untagged mb15"]‘) #返回divelememtn的一个列表
            items = []
            for i in total_div: #遍历div标枪，获取糗事百科每条的内容的全部信息
                author_img = i.xpath(‘./div[@class="author clearfix"]/a[1]/img/@src‘)
                author_img = "https:" + author_img[0] if len(author_img) > 0 else None
                author_name = i.xpath(‘./div[@class="author clearfix"]/a[2]/h2/text()‘)
                author_name = author_name[0] if len(author_name) > 0 else None
                item = dict(
                    author_name=author_name,
                    author_img=author_img 
                )
                items.append(item)
            self.content_queue.put(items)
            self.html_queue.task_done()  #task_done的时候，队列计数减一


    def save _items(self):
        ‘‘‘
        保存items
        :param items:列表
        ‘‘‘

        while self.content_queue.not_empty:
            items = self.content_queue.get()
            f = open("qiubai.txt","a")

            for i in items:
                json.dump(i,f,ensure_ascii=False,indent=2)
                # f.write(json.dumps(i))

            f.close()
            self.content_queue.task_done()


    def run(self):

        # 1.获取url list

        # url_list = self.get_total_url()

        thread_list = []

        thread_url = threading.Thread(target=self.get_total_url)

        thread_list.append(thread_url)

        #发送网络请求

        for i in range(10):

            thread_parse = threading.Thread(target=self.parse_url)

            thread_list.append(thread_parse)

        #提取数据

        thread_get_content = threading.Thread(target=self.get_content)

        thread_list.append(thread_get_content)

        #保存

        thread_save = threading.Thread(target=self.save_items)

        thread_list.append(thread_save)

        for t in thread_list:

            t.set Daemon(True)  #为每个进程设置为后台进程，效果是主进程退出子进程也会退出

            t.start()          #为了解决程序结束无法退出的问题

        #

        # for t in thread_list:

        #     t.join()

 

        self.url_queue.join()   #让主线程等待，所有的队列为空的时候才能退出

        self.html_queue.join()

        self.content_queue.join()

 

if __name__ == "__main__":

    qiubai = Qiubai()

    qiubai.run()    

from selenium import webdriver
# 调用键盘按键操作时需要引入的Keys包
from selenium.webdriver.common.keys import Keys