2. 程式人生 > 實用技巧 >判斷元素是否有滾動條

判斷元素是否有滾動條

阿新 • • 發佈：2020-08-18

目錄

爬蟲

1 爬蟲簡介

爬蟲就是通過程式碼模擬人，向瀏覽器傳送請求(使用模組：requests，selenium)，
獲取到網頁前端程式碼後通過篩選，提取出有用的資料(使用模組：bs4，xpath，re)
最後將資料存放於資料庫或檔案中(檔案，excel，mysql，redis，mongodb)

爬蟲協議

robots.txt (寫了允許爬的路由)

如：https://www.cnblogs.com/robots.txt

2 爬蟲的流程

# 1、發起請求
使用http庫向目標站點發起請求，即傳送一個Request
Request包含：請求頭、請求體、請求地址(瀏覽器除錯，抓包工具)，請求頭(難)，請求體(難)，請求方法

# 2、獲取響應內容
如果伺服器能正常響應，則會得到一個Response
Response包含：html，xml，json，圖片，視訊，經過加密的未知格式(需要解密)等

# 3、解析內容
解析html資料：正則表示式，第三方解析庫如Beautifulsoup，pyquery等
解析json資料：json模組
解析二進位制資料:以b的方式寫入檔案

# 4、儲存資料
資料庫：推薦使用Mongodb(存json格式資料)
檔案

# 5、提高效率
開啟多程序，多執行緒，協程

3 requests模組

安裝：pip3 install requests

3.1 requests模組簡介

# 介紹：
使用requests可以模擬瀏覽器的請求，比起urllib，requests模組的api更加便捷(本質就是封裝了urllib3)


# 注意點：
requests庫傳送請求將網頁內容下載下來以後，並不會執行js程式碼，
需要分析目標站點然後手動發起新的request請求


# 各種請求方式：常用的是get和post
import requests
r = requests.get('https://api.github.com/events')
r = requests.post('http://httpbin.org/post', data = {'key':'value'})
r = requests.put('http://httpbin.org/put', data = {'key':'value'})
r = requests.delete('http://httpbin.org/delete')
r = requests.head('http://httpbin.org/get')
r = requests.options('http://httpbin.org/get')


# 建議在正式學習requests前，先熟悉下HTTP協議
http://www.cnblogs.com/linhaifeng/p/6266327.html

3.2 requests的使用

3.2.1 基本請求

import requests
response=requests.get('http://dig.chouti.com/')
print(response.text)

3.2.2 帶引數的請求

3.2.2.1 帶請求頭引數的方法

# 對百度發請求，攜帶查詢引數:wd=python

# 在請求頭內將自己偽裝成瀏覽器，使用瀏覽器的User-Agent，該引數能顯示請求的來源，否則百度不會正常返回頁面內容，即在請求頭內新增User-Agent
'User-Agent':'Mozilla/5.0 ...'


import requests
response=requests.get('https://www.baidu.com/s?wd=python',headers={'User-Agent':'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.75 Safari/537.36'})
print(response.text)


# 請求頭中較重要的引數

Host
Referer # 大型網站通常都會根據該引數判斷請求的來源(一般檢查是否為本站)
User-Agent # 客戶端(請求來源的客戶端)
Cookie

3.2.2.2 第一種帶查詢引數的方法(不推薦)

# 第一種帶引數的方法:直接在url地址後使用?&=進行拼接，如?name=aaa&age=18
# 使用第一種如果查詢關鍵詞中有中文或者有其他特殊符號，可能會報錯，所以需要將中文進行url編碼
from urllib.parse import urlencode,unquote
# urlencode編碼，unquote解碼

print(urlencode({'wd':'哈哈哈'}))
# wd=%E5%93%88%E5%93%88%E5%93%88

print(unquote('wd=%E5%93%88%E5%93%88%E5%93%88'))
# wd=哈哈哈

import requests
header={'User-Agent':'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.75 Safari/537.36'}

res=requests.get('https://www.baidu.com/s?wd=%E5%93%88%E5%93%88%E5%93%88',headers=header)

3.2.2.3 第二種帶查詢引數的方法(推薦)

import requests
header={'User-Agent':'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.75 Safari/537.36'}

res=requests.get('https://www.baidu.com/s',headers=header,params={'wd':'哈哈哈'})
# 使用params引數，傳入字典即可，自動轉換為url編碼，無需手動轉換

3.2.2.4 手動帶cookie引數的兩種方法

# 登入github，然後從瀏覽器中獲取cookies，就可以直接使用cookie登入了，無需輸入使用者名稱密碼
# 使用者名稱:egonlin 郵箱[email protected] 密碼lhf@123

import requests
# 第一次請求  登入
res=session.post('https://github.com/session',data={"username":"wu",'password':'123'})
# 取出cookie資訊
Cookies={'user_session':'wGMHFJKgDcmRIVvcA14_Wrt_3xaUyJNsBnPbYzEL6L0bHcfc'}
# 下次傳送請求時手動攜帶，傳入cookies，cookies是一個字典或者CookieJar物件
response=requests.get('https://github.com/settings/emails',cookies=Cookies)
# 也可以手動寫入headers中
response=requests.get('https://github.com/settings/emails',headers={"Cookie":Cookies})

# github對請求頭沒有限制，無需定製user-agent，對於其他網站可能需要定製

print('[email protected]' in response.text) #True

3.2.2.5 自動帶cookie引數的方法

import requests

session=requests.session()
# 第一次請求  登入
res=session.post('https://github.com/session',data={"username":"wu",'password':'123'})	
# cookie資訊會自動存入res，下次傳送請求自動攜帶cookie資訊
res2=session.get('https://github.com/settings/emails')

3.2.2.6 帶請求體的方法

# 攜帶資料：urlencoded
res=requests.post('http://127.0.0.1:8000/index/',data={'name':'wu'})
print(res.text)

# 攜帶資料：json
res=requests.post('http://127.0.0.1:8000/index/',json={'age':1,},)
print(res.text)

3.2.3 請求物件的屬性

res=requests.post('http://127.0.0.1:8000/index/',data={'name':'wu'})

print(respone.text)  # 響應的文字

print(respone.content)  # 響應體的二進位制

print(respone.status_code)  # 響應狀態碼

print(respone.headers)    # 響應頭

print(respone.cookies)   # cookie

print(respone.cookies.get_dict()) # 把cookie轉成字典

print(respone.cookies.items())  # [(k1，v1),(k2,v2),(k3,v3)]

print(respone.url)        # 請求的url

print(respone.history)   # []內為重定向之前的歷史記錄響應物件

print(respone.encoding)  # 響應的編碼方式

print(respone.iter_content())  # 視訊，大檔案，可以迴圈取出來
for line in respone.iter_content():
    f.write(line)

3.2.4 頁面亂碼

# 頁面亂碼問題解決方案
res=requests.get('http://www.autohome.com/news')
# 方式一：指定解碼方式
res.encoding='gb2312'
# 方式二：自動解碼
res.encoding=res.apparent_encoding

3.2.5 解析json格式

import json

respone=requests.post('http://127.0.0.1:8000/index/',data={'name':'lqz'})
print(type(respone.text))  # 響應的文字
# 手動序列化
print(json.loads(respone.text))
# 內建的序列化方法
print(respone.json())  # 相當於上面那句話

3.2.6 ssl(瞭解)

import requests

# 對於需要證書的網址，直接訪問會報警告,返回200
respone=requests.get('https://www.12306.cn')
print(respone.status_code)

# 使用證書，需要手動攜帶
import requests

respone=requests.get('https://www.12306.cn',cert=('/path/server.crt','/path/key'))
print(respone.status_code)

3.2.7 代理

import requests

respone=requests.get('http://127.0.0.1:8000/index/',proxies={'http':'代理的地址和埠號',})

# 代理池：列表放了若干代理ip，每次隨機取一個

# 高匿代理與透明代理：如果使用高匿代理，後端一般無法獲取你的ip，使用透明代理，後端能夠直接獲取到你的ip
# 後端如何拿到透明代理的ip：  後端：X-Forwarded-For

respone=requests.get('https://www.baidu.com/',proxies={'http':'27.46.20.226:8888'})
print(respone.text)

3.2.8 設定超時時間

import requests
respone=requests.get('https://www.baidu.com',timeout=0.0001)

3.2.9 認證設定(瞭解)

import requests

r=requests.get('xxx',auth=('user','password'))
# 網頁彈出登入框，現在已經基本絕跡
print(r.status_code)

3.2.10 異常處理

import requests
from requests.exceptions import * 
#可以檢視requests.exceptions獲取異常型別

try:
    r=requests.get('http://www.baidu.com',timeout=0.00001)
except Exception as e:
    print(e)

3.2.11 上傳檔案

import requests

res=requests.post('http://127.0.0.1:8000/index/',files={'myfile':open('a.jpg','rb')})
# files傳字典，value為檔案物件
print(res.text)

3.3 模擬登陸某網站

# http://www.aa7a.cn/
import requests
session=requests.session()
data = {
    'username': '[email protected]',
    'password': 'lqz123',
    'captcha': 'xxxx',		# 驗證碼
    'remember': 1,		# 是否記住密碼
    'ref': 'http://www.aa7a.cn/user.php?act=logout',	# referer
    'act': 'act_login',		# 操作
}
rest = session.post('http://www.aa7a.cn/user.php',data=data)
print(rest.text)
# 拿到cookie
cookie=rest.cookies
print(cookie)

# 攜帶著cookies，表示登入了，頁面中會有我們的使用者資訊[email protected]
rest1=session.get('http://www.aa7a.cn/index.php')
# rest1=requests.get('http://www.aa7a.cn/index.php')
print('[email protected]' in rest1.text)

3.4 爬取梨視訊

# https://www.pearvideo.com/
import requests
import re

res=requests.get('https://www.pearvideo.com/category_loading.jsp?reqType=5&categoryId=1&start=0')


re_video='<a href="(.*?)" class="vervideo-lilink actplay">'
video_urls=re.findall(re_video,res.text)

for video in video_urls:
    url='https://www.pearvideo.com/'+video
    print(url)
    # 向視訊詳情傳送get請求
    res_video=requests.get(url)
    # print(res_video.text)
    re_video_mp4='hdUrl="",sdUrl="",ldUrl="",srcUrl="(.*?)",vdoUrl=srcUrl,skinRes'
    video_url=re.findall(re_video_mp4,res_video.text)[0]
    print(video_url)
    video_name=video_url.rsplit('/',1)[-1]
    print(video_name)
    res_video_content=requests.get(video_url)
    with open(video_name,'wb') as f:
        for line in res_video_content.iter_content():
            f.write(line)

4 beautifulsoup4模組

Beautiful Soup 是一個可以從HTML或XML檔案中提取資料的Python庫.它能夠通過你喜歡的轉換器實現慣用的文件導航,查詢,修改文件的方式.Beautiful Soup會幫你節省數小時甚至數天的工作時間.你可能在尋找 Beautiful Soup3 的文件,Beautiful Soup 3 目前已經停止開發,官網推薦在現在的專案中使用Beautiful Soup 4, 移植到BS4

pip3 install beautifulsoup4  
用於解析/修改html和xml

#安裝 Beautiful Soup
pip install beautifulsoup4

#安裝解析器
Beautiful Soup支援Python標準庫中的HTML解析器,還支援一些第三方的解析器,其中一個是 lxml .根據作業系統不同,可以選擇下列方法來安裝lxml:

$ apt-get install Python-lxml
$ easy_install lxml
$ pip install lxml

另一個可供選擇的解析器是純Python實現的 html5lib , html5lib的解析方式與瀏覽器相同,可以選擇下列方法來安裝html5lib:

$ apt-get install Python-html5lib
$ easy_install html5lib
$ pip install html5lib
解析器 使用方法 優勢 劣勢
Python標準庫 BeautifulSoup(markup, "html.parser") Python的內建標準庫執行速度適中文件容錯能力強 Python 2.7.3 or 3.2.2)前 的版本中文件容錯能力差
lxml HTML 解析器 BeautifulSoup(markup, "lxml") 速度快文件容錯能力強 需要安裝C語言庫
lxml XML 解析器 BeautifulSoup(markup, ["lxml", "xml"])``BeautifulSoup(markup, "xml") 速度快唯一支援XML的解析器 需要安裝C語言庫
html5lib BeautifulSoup(markup, "html5lib") 最好的容錯性以瀏覽器的方式解析文件生成HTML5格式的文件 速度慢不依賴外部擴充套件

4.1 爬取汽車之家新聞

import requests
from bs4 import BeautifulSoup


res=requests.get('https://www.autohome.com.cn/news/1/#liststart')
# print(res.text)

# 第二個引數是解析器型別

# html.parser是python內建的，不需要安裝
soup=BeautifulSoup(res.text,'html.parser')

# 安裝lxml解析器：pip3 install lxml
soup=BeautifulSoup(res.text,'lxml')

# 查詢class為article-wrapper的div
div=soup.find(class_='article-wrapper')
div=soup.find(id='auto-channel-lazyload-article')
print(div)

ul=soup.find(class_='article')
print(ul)


# 繼續找ul下的s所有li
li_list=ul.find_all(name='li')
print(len(li_list))


for li in li_list:
    # 找li中的內容
    title=li.find(name='h3')
    if title:
        title=title.text
        # url=li.find('a')['href']
        url='https:'+li.find('a').attrs.get('href')
        desc=li.find('p').text
        img='https:'+li.find(name='img').get('src')
        print('''
        新聞標題：%s
        新聞地址：%s
        新聞摘要：%s
        新聞圖片：%s
        '''%(title,url,desc,img))

4.2 bs4的使用

4.2.1 基本使用演示

html_doc = """
<html><head><title>The Dormouse's story</title></head>
<body>
<p class="title"><b>The Dormouse's story</b></p>

<p class="story">Once upon a time there were three little sisters; and their names were
<a href="http://example.com/elsie" class="sister" id="link1">Elsie</a>,
<a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> and
<a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>;
and they lived at the bottom of a well.</p>

<p class="story">...</p>
"""

#基本使用：容錯處理,文件的容錯能力指的是在html程式碼不完整的情況下,使用該模組可以識別該錯誤。使用BeautifulSoup解析上述程式碼,能夠得到一個 BeautifulSoup 的物件,並能按照標準的縮排格式的結構輸出
from bs4 import BeautifulSoup
soup=BeautifulSoup(html_doc,'lxml') #具有容錯功能
res=soup.prettify() #處理好縮排，結構化顯示
print(res)

4.2.2 遍歷文件樹

#遍歷文件樹：即直接通過標籤名字選擇，特點是選擇速度快，但如果存在多個相同的標籤則只返回第一個
#1、用法
#2、獲取標籤的名稱
#3、獲取標籤的屬性
#4、獲取標籤的內容
#5、巢狀選擇
#6、子節點、子孫節點
#7、父節點、祖先節點
#8、兄弟節點

#遍歷文件樹：即直接通過標籤名字選擇，特點是選擇速度快，但如果存在多個相同的標籤則只返回第一個
html_doc = """
<html><head><title>The Dormouse's story</title></head>
<body>
<p id="my p" class="title"><b id="bbb" class="boldest">The Dormouse's story</b></p>

<p class="story">Once upon a time there were three little sisters; and their names were
<a href="http://example.com/elsie" class="sister" id="link1">Elsie</a>,
<a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> and
<a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>;
and they lived at the bottom of a well.</p>

<p class="story">...</p>
"""

#1、用法
from bs4 import BeautifulSoup
soup=BeautifulSoup(html_doc,'lxml')
# soup=BeautifulSoup(open('a.html'),'lxml')

print(soup.p) #存在多個相同的標籤則只返回第一個
print(soup.a) #存在多個相同的標籤則只返回第一個

#2、獲取標籤的名稱
print(soup.p.name)

#3、獲取標籤的屬性
print(soup.p.attrs)
p=soup.body.p
# class可能有多個，即便有一個也放到列表中
print(p.attrs)
print(p.attrs.get('class'))
print(p['class'])
print(p.get('class'))

#4、獲取標籤的內容
print(soup.p.string) # p下的文字只有一個時，取到，否則為None
print(soup.p.strings) # 拿到一個生成器物件, 取到p下所有的文字內容
print(soup.p.text) # 取到p下所有的文字內容
for line in soup.stripped_strings: # 去掉空白
    print(line)

'''
如果tag包含了多個子節點,tag就無法確定 .string 方法應該呼叫哪個子節點的內容, .string 的輸出結果是 None，如果只有一個子節點那麼就輸出該子節點的文字，比如下面的這種結構，soup.p.string 返回為None,但soup.p.strings就可以找到所有文字
<p id='list-1'>
    哈哈哈哈
    <a class='sss'>
        <span>
            <h1>aaaa</h1>
        </span>
    </a>
    <b>bbbbb</b>
</p>
'''

# 5、巢狀選擇
print(soup.head.title.string)
print(soup.body.a.string)

# 6、子節點、子孫節點
print(soup.p.contents) # p下所有子節點
print(soup.p.children) # 得到一個迭代器,包含p下所有子節點

for i,child in enumerate(soup.p.children):
    print(i,child)

print(soup.p.descendants) # 獲取子孫節點,p下所有的標籤都會選擇出來
for i,child in enumerate(soup.p.descendants):
    print(i,child)

# 7、父節點、祖先節點
print(soup.a.parent) # 獲取a標籤的父節點
print(soup.a.parents) # 找到a標籤所有的祖先節點，父親的父親，父親的父親的父親...

# 8、兄弟節點
print('=====>')
print(soup.a.next_sibling) # 下一個兄弟
print(soup.a.previous_sibling) # 上一個兄弟

print(list(soup.a.next_siblings)) # 下面的兄弟們=>生成器物件
print(soup.a.previous_siblings) # 上面的兄弟們=>生成器物件

4.2.3 搜尋文件樹

4.2.3.1 過濾器

搜尋文件樹：BeautifulSoup定義了很多搜尋方法,這裡著重介紹2個: find() 和 find_all() .其它方法的引數和用法類似
html_doc = """
<html><head><title>The Dormouse's story</title></head>
<body>
<p id="my p" class="title"><b id="bbb" class="boldest">The Dormouse's story</b>
</p>

<p class="story">Once upon a time there were three little sisters; and their names were
<a href="http://example.com/elsie" class="sister" id="link1">Elsie</a>,
<a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> and
<a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>;
and they lived at the bottom of a well.</p>

<p class="story">...</p>
"""

from bs4 import BeautifulSoup
soup=BeautifulSoup(html_doc,'lxml')

#五種過濾器: 字串、正則表示式、列表、bool、方法

# 字串：即標籤名
print(soup.find_all('b'))
print(soup.find(href='http://example.com/elsie'))
print(soup.find(attrs={'id':'my_p'}))


# 正則表示式
import re
print(soup.find_all(re.compile('^b'))) #找出b開頭的標籤，結果有body和b標籤


# 列表：如果傳入列表引數,Beautiful Soup會將與列表中任一元素匹配的內容返回.下面程式碼找到文件中所有<a>標籤和<b>標籤:
print(soup.find_all(['a','b']))
print(soup.find_all(class_=['sister','title']))


# bool：可以匹配任何值,下面程式碼查詢到所有的tag,但是不會返回字串節點
print(soup.find_all(id=False))
print(soup.find_all(href=True))
    
# 方法(瞭解):如果沒有合適過濾器,那麼還可以定義一個方法,方法只接受一個元素引數 ,如果這個方法返回 True 表示當前元素匹配並且被找到,如果不是則反回 False
def has_class_but_no_id(tag):
    return tag.has_attr('class') and not tag.has_attr('id')

print(soup.find_all(has_class_but_no_id))





# bs4的修改文件樹  軟體配置檔案是xml格式的

# 軟體的配置檔案
# ini：configparser
# conf
# xml：bs4
# yaml格式

4.2.3.2 find_all

# find_all( name , attrs , recursive , text , **kwargs )


# name: 搜尋name引數的值可以使任一型別的 過濾器 ,字元竄,正則表示式,列表,方法或是 True .
print(soup.find_all(name=re.compile('^t')))

# keyword: key=value的形式，value可以是過濾器：字串 , 正則表示式 , 列表, True .
print(soup.find_all(id=re.compile('my')))
print(soup.find_all(href=re.compile('lacie'),id=re.compile('\d'))) #注意類要用class_
print(soup.find_all(id=True)) #查詢有id屬性的標籤

# 有些tag屬性在搜尋不能使用,比如HTML5中的 data-* 屬性:
data_soup = BeautifulSoup('<div data-foo="value">foo!</div>','lxml')
# data_soup.find_all(data-foo="value") #報錯：SyntaxError: keyword can't be an expression
# 但是可以通過 find_all() 方法的 attrs 引數定義一個字典引數來搜尋包含特殊屬性的tag:
print(data_soup.find_all(attrs={"data-foo": "value"}))
# [<div data-foo="value">foo!</div>]

# 按照類名查詢，注意關鍵字是class_，class_=value,value可以是五種選擇器之一
print(soup.find_all('a',class_='sister')) #查詢類為sister的a標籤
print(soup.find_all('a',class_='sister ssss')) #查詢類為sister和sss的a標籤，順序錯誤也匹配不成功
print(soup.find_all(class_=re.compile('^sis'))) #查詢類為sister的所有標籤

# attrs
print(soup.find_all('p',attrs={'class':'story'}))

# text: 值可以是：字元，列表，True，正則
print(soup.find_all(text='Elsie'))
print(soup.find_all('a',text='Elsie'))

# limit引數:如果文件樹很大那麼搜尋會很慢.如果我們不需要全部結果,可以使用 limit 引數限制返回結果的數量.效果與SQL中的limit關鍵字類似,當搜尋到的結果數量達到 limit 的限制時,就停止搜尋返回結果
print(soup.find_all('a',limit=2))

# recursive:呼叫tag的 find_all() 方法時,Beautiful Soup會檢索當前tag的所有子孫節點,如果只想搜尋tag的直接子節點,可以使用引數 recursive=False.即只查詢第一層
print(soup.html.find_all('a'))
print(soup.html.find_all('a',recursive=False))

'''
像呼叫 find_all() 一樣呼叫tag
find_all() 幾乎是Beautiful Soup中最常用的搜尋方法,所以我們定義了它的簡寫方法. BeautifulSoup 物件和 tag 物件可以被當作一個方法來使用,這個方法的執行結果與呼叫這個物件的 find_all() 方法相同,下面兩行程式碼是等價的:
soup.find_all("a")
soup("a")
這兩行程式碼也是等價的:
soup.title.find_all(text=True)
soup.title(text=True)
'''

4.2.3.3 find

# find( name , attrs , recursive , text , **kwargs )


find_all() 方法將返回文件中符合條件的所有tag,儘管有時候我們只想得到一個結果.比如文件中只有一個<body>標籤,那麼使用 find_all() 方法來查詢<body>標籤就不太合適, 使用 find_all 方法並設定 limit=1 引數不如直接使用 find() 方法.下面兩行程式碼是等價的:

soup.find_all('title', limit=1)
# [<title>The Dormouse's story</title>]
soup.find('title')
# <title>The Dormouse's story</title>

唯一的區別是 find_all() 方法的返回結果是值包含一個元素的列表,而 find() 方法直接返回結果.
find_all() 方法沒有找到目標是返回空列表, find() 方法找不到目標時,返回 None .
print(soup.find("nosuchtag"))
# None

soup.head.title 是 tag的名字 方法的簡寫.這個簡寫的原理就是多次呼叫當前tag的 find() 方法:

soup.head.title
# <title>The Dormouse's story</title>
soup.find("head").find("title")
# <title>The Dormouse's story</title>

https://www.crummy.com/software/BeautifulSoup/bs4/doc/index.zh.html#find-parents-find-parent

4.2.3.4 修改文件樹

https://www.crummy.com/software/BeautifulSoup/bs4/doc/index.zh.html#id40

4.2.3.5 CSS選擇器

# 該模組提供了select方法來支援css,詳見官網:https://www.crummy.com/software/BeautifulSoup/bs4/doc/index.zh.html#id37


html_doc = """
<html><head><title>The Dormouse's story</title></head>
<body>
<p class="title">
    <b>The Dormouse's story</b>
    Once upon a time there were three little sisters; and their names were
    <a href="http://example.com/elsie" class="sister" id="link1">
        <span>Elsie</span>
    </a>
    <a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> and
    <a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>;
    <div class='panel-1'>
        <ul class='list' id='list-1'>
            <li class='element'>Foo</li>
            <li class='element'>Bar</li>
            <li class='element'>Jay</li>
        </ul>
        <ul class='list list-small' id='list-2'>
            <li class='element'><h1 class='yyyy'>Foo</h1></li>
            <li class='element xxx'>Bar</li>
            <li class='element'>Jay</li>
        </ul>
    </div>
    and they lived at the bottom of a well.
</p>
<p class="story">...</p>
"""



from bs4 import BeautifulSoup
soup=BeautifulSoup(html_doc,'lxml')


#1、CSS選擇器
print(soup.p.select('.sister'))
print(soup.select('.sister span'))

print(soup.select('#link1'))
print(soup.select('#link1 span'))

print(soup.select('#list-2 .element.xxx'))

print(soup.select('#list-2')[0].select('.element')) #可以一直select,但其實沒必要,一條select就可以了

# 2、獲取屬性
print(soup.select('#list-2 h1')[0].attrs)

# 3、獲取內容
print(soup.select('#list-2 h1')[0].get_text())

4.2.3.6 總結

# 總結:

#1、推薦使用lxml解析庫

#2、三種選擇器:
	標籤選擇器,find與find_all，css選擇器
    1、標籤選擇器篩選功能弱,但是速度快
    2、建議使用find,find_all查詢匹配單個結果或者多個結果
    3、如果對css選擇器非常熟悉建議使用select
    
#3、獲取屬性attrs和獲取文字值get_text()

5 代理池搭建

# 從github下載免費代理池開原始碼(建議閱讀原始碼)
git clone [email protected]:jhao104/proxy_pool.git
    
    
# pycharm開啟，修改配置檔案(reids地址修改)
# 啟動爬蟲：
python3 proxyPool.py schedule
# 啟動服務：
python3 proxyPool.py server


# 隨機獲取代理
requests.get("http://127.0.0.1:5010/get/").json()
# 刪除一個代理
requests.get("http://127.0.0.1:5010/delete/?proxy={}".format(proxy))

6 驗證碼破解之打碼平臺

# 驗證碼破解的方法：
	1 影象處理(困難)
    	pytesseract
        百度文字識別
        pillow
	2 專業打碼平臺，破解驗證碼(收費)

    
# 打碼平臺：
# 申請超級鷹，註冊
# 登入，下載sdk(程式碼如下)，填入使用者名稱密碼，軟體id



# !/usr/bin/env python
# coding:utf-8
import requests
from hashlib import md5

class Chaojiying_Client():

    def __init__(self, username, password, soft_id):
        self.username = username
        password =  password.encode('utf8')
        self.password = md5(password).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 PostPic(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 ReportError(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()


if __name__ == '__main__':
    chaojiying = Chaojiying_Client('306334678', 'lqz12345', '903641')	
    #使用者中心>>軟體ID 生成一個替換 96001
    im = open('a.jpg', 'rb').read()
    #本地圖片檔案路徑 來替換 a.jpg 有時WIN系統須要//
    print(chaojiying.PostPic(im, 1902))
    #1902 驗證碼型別  官方網站>>價格體系 3.4+版 print 後要加()

7 爬拉勾網職位資訊

爬取拉勾網需要先獲取第一個頁面的cookie，

攜帶該cookie才能跳轉到下一個頁面

# https://www.lagou.com/jobs/positionAjax.json?city=%E4%B8%8A%E6%B5%B7&needAddtionalResult=false


import requests


payload = {
    'first': 'true',
    'pn': '1',
    'kd': 'python',
}

header = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.86 Safari/537.36',
    'Referer': 'https://www.lagou.com/jobs/list_python?labelWords=&fromSearch=true&suginput=',
    'Accept': 'application/json, text/javascript, */*; q=0.01'
}

# 實際要爬取的url
url = 'https://www.lagou.com/jobs/positionAjax.json?needAddtionalResult=false'

# 原始的url
urls ='https://www.lagou.com/jobs/list_python?labelWords=&fromSearch=true&suginput='
# 建立session，可以自動攜帶cookie
s = requests.Session()
# 獲取搜尋頁的cookies
s.get(urls, headers=header, timeout=3)# 可從s.cookies中獲取cookie
# 獲取此次文字
response = s.post(url, data=payload, headers=header, timeout=5).text
print(response)

8 爬《三國演義》

# https://www.shicimingju.com/book/sanguoyanyi.html

def write(name, title, content):
    with open(f'{name}.txt', 'a', encoding='utf-8') as f:
        f.write(title)
        f.write('\n')
        f.write(content)
        f.write('\n\n')


for num in range(1,500):
    res = requests.get(f'https://www.shicimingju.com/book/sanguoyanyi/{num}.html', )
    soup = BeautifulSoup(res.text, 'lxml')
    try:
        name = soup.select('#nav-top a:last-child')[0].text
        title = soup.h1.text
        print(title)
        content = soup.select(".chapter_content")[0].text
        # print(content)
        write(name, title, content)
        print(f'第{num}章下完了')
        # break
    except Exception as e:
        # print(e)
        print(f'{title}下完了')
        break

9 爬肯德基門店

# http://www.kfc.com.cn/kfccda/ashx/GetStoreList.ashx?op=keyword
import requests


def write(store_list):
    with open('kfc_sh.txt', 'a', encoding='utf-8') as f:
        # id = 1
        for store in store_list:
            f.write(
                f"id:{store['rownum']},storeName:{store['storeName']},addressDetail:{store['addressDetail']},pro:{store['pro']}")
            f.write('\n\n')
            print(f"已下載{store['rownum']}/{num}")


for page in range(1, 20000):
    data = {'cname': '上海', 'pid': '', 'pageIndex': page, 'pageSize': 10}
    res = requests.post('http://www.kfc.com.cn/kfccda/ashx/GetStoreList.ashx?op=cname', data=data)
    # print(res.text)
    store_list = res.json().get('Table1')
    if not store_list:
        break
    # print(store_list)
    num = res.json().get('Table')[0].get('rowcount')
    write(store_list)

10 爬糗事百科段子

#https://www.qiushibaike.com/text/page/2/

import requests
from bs4 import BeautifulSoup


ret=requests.get('https://www.qiushibaike.com/text/page/2/')
# print(ret.text)

soup=BeautifulSoup(ret.text,'html.parser')

article_list=soup.find_all(class_='article')
# print(article_list)
for article in article_list:
    content=article.find(class_='content').text
    print(content)
    print('-------')

11 selenium使用

11.1 selenium簡介

selenium最初是一個自動化測試工具,而爬蟲中使用它主要是為了解決requests無法直接執行JavaScript程式碼的問題

selenium本質是通過驅動瀏覽器，完全模擬瀏覽器的操作，比如跳轉、輸入、點選、下拉等，來拿到網頁渲染之後的結果，可支援多種瀏覽器

from selenium import webdriver

browser=webdriver.Chrome()
browser=webdriver.Firefox()
browser=webdriver.PhantomJS()
browser=webdriver.Safari()
browser=webdriver.Edge()

11.2 selenium安裝

11.2.1 常規瀏覽器

#安裝：selenium+chromedriver
pip3 install selenium
下載chromdriver.exe放到python安裝路徑的scripts目錄中即可
國內映象網站地址：http://npm.taobao.org/mirrors/chromedriver/
最新的版本去官網找:https://sites.google.com/a/chromium.org/chromedriver/downloads

        
        
#驗證安裝
C:\Users\Administrator>python3
Python 3.6.1 (v3.6.1:69c0db5, Mar 21 2017, 18:41:36) [MSC v.1900 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.

from selenium import webdriver
driver=webdriver.Chrome() #彈出瀏覽器
driver.get('https://www.baidu.com')
driver.page_source



#注意：
selenium3預設支援的webdriver是Firfox，而Firefox需要安裝geckodriver
下載連結：https://github.com/mozilla/geckodriver/releases

11.2.2 無介面瀏覽器

PhantomJS(不再更新)

#安裝：selenium+phantomjs
pip3 install selenium
下載phantomjs，解壓後把phantomjs.exe所在的bin目錄放到環境變數
下載連結：http://phantomjs.org/download.html

    
#驗證安裝
C:\Users\Administrator>phantomjs
phantomjs> console.log('egon gaga')
egon gaga
undefined
phantomjs>



C:\Users\Administrator>python3
Python 3.6.1 (v3.6.1:69c0db5, Mar 21 2017, 18:41:36) [MSC v.1900 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.

from selenium import webdriver
driver=webdriver.PhantomJS() #無介面瀏覽器
driver.get('https://www.baidu.com')
driver.page_source

在 PhantomJS 年久失修, 後繼無人的節骨眼

Chrome 出來救場, 再次成為了反爬蟲 Team 的噩夢

自Google 釋出 chrome 59 / 60 正式版 開始便支援Headless mode

這意味著在無 GUI 環境下, PhantomJS 不再是唯一選擇

# selenium:3.12.0
# webdriver:2.38
# chrome.exe: 65.0.3325.181(正式版本) (32 位)

from selenium import webdriver
from selenium.webdriver.chrome.options import Options
chrome_options = Options()
chrome_options.add_argument('window-size=1920x3000') # 指定瀏覽器解析度
chrome_options.add_argument('--disable-gpu') # 谷歌文件提到需要加上這個屬性來規避bug
chrome_options.add_argument('--hide-scrollbars') # 隱藏滾動條, 應對一些特殊頁面
chrome_options.add_argument('blink-settings=imagesEnabled=false') #不載入圖片, 提升速度
chrome_options.add_argument('--headless') # 瀏覽器不提供視覺化頁面. linux下如果系統不支援視覺化不加這條會啟動失敗


bro=webdriver.Chrome(chrome_options=chrome_options,executable_path='./chromedriver.exe')
driver.get('https://www.baidu.com')
print(bro.page_source)
print('hao123' in driver.page_source)
driver.close() #切記關閉瀏覽器，回收資源

11.3 selenium基本使用

from selenium import webdriver
from selenium.webdriver import ActionChains
from selenium.webdriver.common.by import By  # 按照什麼方式查詢，By.ID,By.CSS_SELECTOR
from selenium.webdriver.common.keys import Keys  # 鍵盤按鍵操作
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.wait import WebDriverWait  # 等待頁面載入某些元素

browser = webdriver.Chrome(executable_path='./chromedriver.exe')	# 指定驅動
# 開啟一個Chrome瀏覽器
try:
    browser.get('https://www.baidu.com')	# 輸入url地址

    input_tag = browser.find_element_by_id('kw')	# 找到搜尋框
    input_tag.send_keys('美女')  # 在搜尋框中加入內容	python2中輸入中文錯誤，字串前加個u
    input_tag.send_keys(Keys.ENTER)  # 輸入回車

    wait = WebDriverWait(browser, 10)
    wait.until(EC.presence_of_element_located((By.ID, 'content_left')))  # 等到id為content_left的元素載入完畢,最多等10秒

    print(browser.page_source)
    print(browser.current_url)
    print(browser.get_cookies())


finally:
    browser.close()

11.4 selenium的選擇器

# 官網連結：http://selenium-python.readthedocs.io/locating-elements.html


#===============所有方法===================
# 1、find_element_by_id		# 通過id查詢標籤
# 2、find_element_by_link_text		# 通過連結文字查詢連結標籤
# 3、find_element_by_partial_link_text		# 通過連結的部分文字查詢連結標籤
# 4、find_element_by_tag_name		# 通過標籤(span)查詢標籤
# 5、find_element_by_class_name		# 通過標籤class查詢標籤
# 6、find_element_by_name		# 通過標籤name屬性查詢標籤
# 7、find_element_by_css_selector		# 通過css選擇器查詢標籤
# 8、find_element_by_xpath		# 通過xpath查詢標籤

# 強調：
# 1、上述均可以改寫成find_element(By.ID,'kw')的形式
# 2、find_elements_by_xxx的形式是查詢到多個元素，結果為列表



from selenium import webdriver
from selenium.webdriver import ActionChains
from selenium.webdriver.common.by import By #按照什麼方式查詢，By.ID,By.CSS_SELECTOR
from selenium.webdriver.common.keys import Keys #鍵盤按鍵操作
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.wait import WebDriverWait #等待頁面載入某些元素
import time

driver=webdriver.Chrome(executable_path='./chromedriver.exe')
driver.get('https://www.baidu.com')
wait=WebDriverWait(driver,10)


#===============示範用法===================
# 1、find_element_by_id
print(driver.find_element_by_id('kw'))
# 查詢id為kw的標籤

# 2、find_element_by_link_text
login=driver.find_element_by_link_text('登入')
login.click()
# 查詢連結文字為登入的連結標籤，並點選它

# 3、find_element_by_partial_link_text
login=driver.find_elements_by_partial_link_text('錄')[0]
login.click()
# 查詢連結文字中有錄的連結標籤，並點選它

# 4、find_element_by_tag_name
print(driver.find_element_by_tag_name('a'))
# 查詢第一個a標籤

# 5、find_element_by_class_name
button=wait.until(EC.element_to_be_clickable((By.CLASS_NAME,'tang-pass-footerBarULogin')))
button.click()
# 查詢class為tang-pass-footerBarULogin的標籤，並點選它


# 6、find_element_by_name
input_user=wait.until(EC.presence_of_element_located((By.NAME,'userName')))
input_pwd=wait.until(EC.presence_of_element_located((By.NAME,'password')))
commit=wait.until(EC.element_to_be_clickable((By.ID,'TANGRAM__PSP_10__submit')))
# 查詢name屬性為userName和password的標籤


input_user.send_keys('18611453110')
# 在input標籤內輸入18611453110
input_pwd.send_keys('xxxxxx')
# 在input標籤內輸入xxxxxx
commit.click()
# 點選登入

# 7、find_element_by_css_selector
driver.find_element_by_css_selector('#kw')
# 查詢id為kw的標籤(css選擇器)

# 8、find_element_by_xpath
driver.find_element_by_xpath('//a')
# 查詢所有a標籤(xpath)

11.5 模擬登入百度

# 模擬登陸百度
from selenium import webdriver
import time

bro = webdriver.Chrome(executable_path='./chromedriver.exe')

bro.get('https://www.baidu.com/')
time.sleep(0.01)
input_k = bro.find_element_by_id('kw')
input_k.send_keys('美女')  # 在框裡寫入美女
time.sleep(2)
sou = bro.find_element_by_id('su')  # 找到搜尋按鈕
sou.click()  # 點選搜尋按鈕
time.sleep(4)
bro.close()

from selenium import webdriver
import time

bro = webdriver.Chrome(executable_path='./chromedriver.exe')
bro.implicitly_wait(5)  # 隱式等待：找一個控制元件，如果控制元件沒有加載出來，等待5s中  等待所有，只需要寫著一句，以後找所有控制元件都按這個操作來
bro.get('https://www.baidu.com/')

d_button = bro.find_element_by_link_text('登入')

d_button.click()

login_u = bro.find_element_by_id('TANGRAM__PSP_11__footerULoginBtn')
login_u.click()

username = bro.find_element_by_id('TANGRAM__PSP_11__userName')
username.send_keys('yxp654799481')
password = bro.find_element_by_id('TANGRAM__PSP_11__password')
password.send_keys('yxp997997')
time.sleep(3)
submit = bro.find_element_by_id('TANGRAM__PSP_11__submit')

submit.click()
time.sleep(10)

print(bro.get_cookies())

bro.close()

11.6 xpath選擇器使用

# xpath: XPath 是一門在 XML 文件中查詢資訊的語言
# / :從根節點選取。
# // :不管位置，直接找
# /@屬性名		獲取屬性
# /text()	獲取文字內容
# 可以從瀏覽器複製(copy xpath)

doc = '''
<html>
 <head>
  <base href='http://example.com/' />
  <title>Example website</title>
 </head>
 <body>
  <div id='images'>
   <a href='image1.html'>Name: My image 1 <br /><img src='image1_thumb.jpg' /></a>
   <a href='image2.html'>Name: My image 2 <br /><img src='image2_thumb.jpg' /></a>
   <a href='image3.html'>Name: My image 3 <br /><img src='image3_thumb.jpg' /></a>
   <a href='image4.html'>Name: My image 4 <br /><img src='image4_thumb.jpg' /></a>
   <a href='image5.html' class='li li-item' name='items'>Name: My image 5 <br /><img src='image5_thumb.jpg' /></a>
   <a href='image6.html' name='items'><span><h5>test</h5></span>Name: My image 6 <br /><img src='image6_thumb.jpg' /></a>
  </div>
 </body>
</html>
'''
from lxml import etree

html = etree.HTML(doc)
# html=etree.parse('search.html',etree.HTMLParser())
# 1 所有節點
a = html.xpath('//*')
# 2 指定節點(結果為列表)
a = html.xpath('//head')
# 3 子節點，子孫節點
a = html.xpath('//div/a')
a = html.xpath('//body/a')  # 無資料
a = html.xpath('//body//a')
# 4 父節點
a = html.xpath('//body//a[@href="image1.html"]/..')
a = html.xpath('//body//a[1]/..')
# 也可以這樣
a = html.xpath('//body//a[1]/parent::*')
# 5 屬性匹配
a = html.xpath('//body//a[@href="image1.html"]')

# 6 文字獲取	/text() 取當前標籤的文字
a = html.xpath('//body//a[@href="image1.html"]/text()')

# 7 屬性獲取  	@href 取當前標籤的屬性
a = html.xpath('//body//a/@href')
# 注意從1 開始取(不是從0)
a = html.xpath('//body//a[1]/@href')
# 8 屬性多值匹配
# a 標籤有多個class類，直接匹配就不可以了，需要用contains
a = html.xpath('//body//a[@class="li"]')
a = html.xpath('//body//a[contains(@class,"li")]')
a = html.xpath('//body//a[contains(@class,"li")]/text()')
# 9 多屬性匹配
a = html.xpath('//body//a[contains(@class,"li") or @name="items"]')
a = html.xpath('//body//a[contains(@class,"li") and @name="items"]/text()')
# a=html.xpath('//body//a[contains(@class,"li")]/text()')
# 10 按序選擇
a = html.xpath('//a[2]/text()')
a = html.xpath('//a[2]/@href')
# 取最後一個
a = html.xpath('//a[last()]/@href')
# 位置小於3的
a = html.xpath('//a[position()<3]/@href')
# 倒數第二個
a = html.xpath('//a[last()-2]/@href')
# 11 節點軸選擇
# ancestor：祖先節點
# 使用了* 獲取所有祖先節點
a = html.xpath('//a/ancestor::*')
# 獲取祖先節點中的div
a = html.xpath('//a/ancestor::div')
# attribute：屬性值
a = html.xpath('//a[1]/attribute::*')
# child：直接子節點
a = html.xpath('//a[1]/child::*')
# descendant：所有子孫節點
a = html.xpath('//a[6]/descendant::*')
# following:當前節點之後所有節點
a = html.xpath('//a[1]/following::*')
a = html.xpath('//a[1]/following::*[1]/@href')
# following-sibling:當前節點之後同級節點
a = html.xpath('//a[1]/following-sibling::*')
a = html.xpath('//a[1]/following-sibling::a')
a = html.xpath('//a[1]/following-sibling::*[2]')
a = html.xpath('//a[1]/following-sibling::*[2]/@href')

print(a)


# 官網連結：http://selenium-python.readthedocs.io/locating-elements.html
from selenium import webdriver
from selenium.webdriver import ActionChains
from selenium.webdriver.common.by import By  # 按照什麼方式查詢，By.ID,By.CSS_SELECTOR
from selenium.webdriver.common.keys import Keys  # 鍵盤按鍵操作
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.wait import WebDriverWait  # 等待頁面載入某些元素
import time

driver = webdriver.PhantomJS()
driver.get('https://doc.scrapy.org/en/latest/_static/selectors-sample1.html')
# wait=WebDriverWait(driver,3)
driver.implicitly_wait(3)  # 使用隱式等待

try:
    # find_element_by_xpath
    # //與/
    # driver.find_element_by_xpath('//body/a')  # 開頭的//代表從整篇文件中尋找,body之後的/代表body的兒子，這一行找不到就會報錯了

    driver.find_element_by_xpath('//body//a')  # 開頭的//代表從整篇文件中尋找,body之後的//代表body的子子孫孫
    driver.find_element_by_css_selector('body a')


    # 取第n個
    res1 = driver.find_elements_by_xpath('//body//a[1]')  # 取第一個a標籤
    print(res1[0].text)
    
    # 按照屬性查詢,下述三者查詢效果一樣
    res1 = driver.find_element_by_xpath('//a[5]')
    res2 = driver.find_element_by_xpath('//a[@href="image5.html"]')
    res3 = driver.find_element_by_xpath('//a[contains(@href,"image5")]')  # 模糊查詢
    print('==>', res1.text)
    print('==>', res2.text)
    print('==>', res3.text)
    
    # 其他
    res1 = driver.find_element_by_xpath('/html/body/div/a')
    print(res1.text)
    
    res2 = driver.find_element_by_xpath('//a[img/@src="image3_thumb.jpg"]')  
    # 找到子標籤img的src屬性為image3_thumb.jpg的a標籤
    print(res2.tag_name, res2.text)
    
    res3 = driver.find_element_by_xpath("//input[@name='continue'][@type='button']")  
    # 檢視屬性name為continue且屬性type為button的input標籤
    res4 = driver.find_element_by_xpath("//*[@name='continue'][@type='button']")  
    # 檢視屬性name為continue且屬性type為button的所有標籤
    
    time.sleep(5)


finally:
    driver.close()

11.7 selenium標籤的屬性

.text
.location
.size
.get_attribute('href')
.get_cookies()

from selenium import webdriver
from selenium.webdriver import ActionChains
from selenium.webdriver.common.by import By #按照什麼方式查詢，By.ID,By.CSS_SELECTOR
from selenium.webdriver.common.keys import Keys #鍵盤按鍵操作
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.wait import WebDriverWait #等待頁面載入某些元素

browser=webdriver.Chrome()

browser.get('https://www.amazon.cn/')

wait=WebDriverWait(browser,10)
wait.until(EC.presence_of_element_located((By.ID,'cc-lm-tcgShowImgContainer')))

tag=browser.find_element(By.CSS_SELECTOR,'#cc-lm-tcgShowImgContainer img')

#獲取標籤屬性，
print(tag.text)   # 獲取文字內容
print(tag.get_attribute('src'))	# 獲取tag的src屬性

#獲取標籤ID，位置，名稱，大小(瞭解)
print(tag.id)
print(tag.location)
print(tag.tag_name)
print(tag.size)

browser.close()

11.8 隱式等待和顯式等待

#1、selenium只是模擬瀏覽器的行為，而瀏覽器解析頁面是需要時間的(執行css，js)，一些元素可能需要過一段時間才能加載出來，為了保證能查詢到元素，必須等待

#2、等待的方式分兩種：
隱式等待：在browser.get('xxx')前就設定，針對所有元素有效
顯式等待：在browser.get('xxx')之後設定，只針對某個元素有效

11.8.1 隱式等待

from selenium import webdriver
from selenium.webdriver import ActionChains
from selenium.webdriver.common.by import By  # 按照什麼方式查詢，By.ID,By.CSS_SELECTOR
from selenium.webdriver.common.keys import Keys  # 鍵盤按鍵操作
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.wait import WebDriverWait  # 等待頁面載入某些元素

browser = webdriver.Chrome()

# 隱式等待:在查詢所有元素時，如果尚未被載入，則等10秒
browser.implicitly_wait(10)

browser.get('https://www.baidu.com')

input_tag = browser.find_element_by_id('kw')
input_tag.send_keys('美女')
input_tag.send_keys(Keys.ENTER)

contents = browser.find_element_by_id('content_left')  # 沒有等待環節而直接查詢，找不到則會報錯
print(contents)

browser.close()

11.8.2 顯式等待

from selenium import webdriver
from selenium.webdriver import ActionChains
from selenium.webdriver.common.by import By  # 按照什麼方式查詢，By.ID,By.CSS_SELECTOR
from selenium.webdriver.common.keys import Keys  # 鍵盤按鍵操作
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.wait import WebDriverWait  # 等待頁面載入某些元素

browser = webdriver.Chrome()
browser.get('https://www.baidu.com')

input_tag = browser.find_element_by_id('kw')
input_tag.send_keys('美女')
input_tag.send_keys(Keys.ENTER)

# 顯式等待：顯式地等待某個元素被載入
wait = WebDriverWait(browser, 10)
wait.until(EC.presence_of_element_located((By.ID, 'content_left')))

contents = browser.find_element(By.CSS_SELECTOR, '#content_left')
print(contents)

browser.close()

11.9 元素互動操作

11.9.1 簡單互動

input_tag.clear() 	# 清空輸入框
input_tag.send_keys('iphone7plus')	# 在輸入框增加內容
button.click()		# 點選該標籤
input_tag.send_keys(Keys.ENTER)		# 按下回車鍵
browser.execute_script('alert("hello world")')	# 執行js程式碼


from selenium.webdriver.common.keys import Keys  # 鍵盤按鍵操作

11.9.2 動作鏈

from selenium import webdriver
from selenium.webdriver import ActionChains
from selenium.webdriver.common.by import By  # 按照什麼方式查詢，By.ID,By.CSS_SELECTOR
from selenium.webdriver.common.keys import Keys  # 鍵盤按鍵操作
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.wait import WebDriverWait  # 等待頁面載入某些元素
import time

driver = webdriver.Chrome()
driver.get('http://www.runoob.com/try/try.php?filename=jqueryui-api-droppable')
wait = WebDriverWait(driver, 3)
# driver.implicitly_wait(3)  # 使用隱式等待

try:
    driver.switch_to.frame('iframeResult')  ##切換到iframeResult
    sourse = driver.find_element_by_id('draggable')
    target = driver.find_element_by_id('droppable')

    # 方式一：基於同一個動作鏈序列執行
    # actions=ActionChains(driver) #拿到動作鏈物件
    # actions.drag_and_drop(sourse,target) #把動作放到動作鏈中，準備序列執行
    # actions.perform()

    # 方式二：不同的動作鏈，每次移動的位移都不同

    ActionChains(driver).click_and_hold(sourse).perform()
    distance = target.location['x'] - sourse.location['x']

    track = 0
    while track < distance:
        ActionChains(driver).move_by_offset(xoffset=2, yoffset=0).perform()
        track += 2

    ActionChains(driver).release().perform()

    time.sleep(10)


finally:
    driver.close()

11.9.3 執行js程式碼

from selenium import webdriver

browser = webdriver.Chrome()
try:
    browser.get('https://www.baidu.com')
    browser.execute_script('alert("hello world")')  # 列印警告
finally:
    browser.close()

11.9.4 切換frame

# frame相當於一個單獨的網頁，在父frame裡是無法直接檢視到子frame的元素的，必須switch_to_frame切到該frame下，才能進一步查詢

from selenium import webdriver

browser = webdriver.Chrome()

try:
    browser.get('http://www.runoob.com/try/try.php?filename=jqueryui-api-droppable')

    browser.switch_to.frame('iframeResult')  # 切換到id為iframeResult的frame

    tag1 = browser.find_element_by_id('droppable')
    print(tag1)

    # tag2=browser.find_element_by_id('textareaCode') 
    # 報錯，在子frame裡無法檢視到父frame的元素
    browser.switch_to.parent_frame()  # 切回父frame,就可以查詢到了
    tag2 = browser.find_element_by_id('textareaCode')
    print(tag2)

finally:
    browser.close()

11.10 其他

11.10.1 模擬瀏覽器的前進後退

import time
from selenium import webdriver

browser=webdriver.Chrome()
browser.get('https://www.baidu.com')
browser.get('https://www.taobao.com')
browser.get('http://www.sina.com.cn/')

browser.back()
time.sleep(10)
browser.forward()
browser.close()

# 如何把螢幕拉倒最後(js控制)
# bro.execute_script('window.scrollTo(0,document.body.offsetHeight)')

11.10.2 獲取cookie

from selenium import webdriver

browser=webdriver.Chrome()
browser.get('https://www.zhihu.com/explore')
print(browser.get_cookies())
browser.add_cookie({'k1':'xxx','k2':'yyy'})
print(browser.get_cookies())

# browser.delete_all_cookies()

11.10.3 選項卡管理

# 選項卡管理：切換選項卡，有js的方式windows.open,有windows快捷鍵：ctrl+t等，最通用的就是js的方式
import time
from selenium import webdriver

browser=webdriver.Chrome()
browser.get('https://www.baidu.com')
browser.execute_script('window.open()')

print(browser.window_handles) #獲取所有的選項卡
browser.switch_to_window(browser.window_handles[1])
browser.get('https://www.taobao.com')
time.sleep(10)
browser.switch_to_window(browser.window_handles[0])
browser.get('https://www.sina.com.cn')
browser.close()

11.10.4 異常處理

from selenium import webdriver
from selenium.common.exceptions import TimeoutException,NoSuchElementException,NoSuchFrameException

try:
    browser=webdriver.Chrome()
    browser.get('http://www.runoob.com/try/try.php?filename=jqueryui-api-droppable')
    browser.switch_to.frame('iframssseResult')

except TimeoutException as e:
    print(e)
except NoSuchFrameException as e:
    print(e)
finally:
    browser.close()

12 爬取京東商品資訊

from selenium import webdriver
import time
# 模擬鍵盤輸入
from selenium.webdriver.common.keys import Keys
bro=webdriver.Chrome(executable_path='./chromedriver.exe')
# 設定隱士等待
bro.implicitly_wait(10)

def get_goods_info(bro):
    # li_list=bro.find_element_by_class_name('gl-warp').find_elements_by_tag_name('li')
    # goods=bro.find_elements_by_class_name('gl-item')
    goods = bro.find_elements_by_css_selector('.gl-item')
    # print(len(goods))
    for good in goods:
        try:
            price = good.find_element_by_css_selector('.p-price i').text
            name = good.find_element_by_css_selector('.p-name em').text
            url = good.find_element_by_css_selector('.p-img a').get_attribute('href')
            commits = good.find_element_by_css_selector('.p-commit strong>a').text
            photo_url = good.find_element_by_css_selector('.p-img img').get_attribute('src')

            print('''
            商品名字：%s
            商品價格：%s
            商品地址：%s
            商品評論數：%s
            商品圖片地址：%s
    
            ''' % (name, price, url, commits, photo_url))
        except Exception as e:
            continue

    next_button = bro.find_element_by_partial_link_text('下一頁')
    time.sleep(1)
    next_button.click()

    get_goods_info(bro)

try:
    bro.get('https://www.jd.com/')

    input_k=bro.find_element_by_id('key')

    input_k.send_keys('奶牛')
    # 模擬鍵盤的回車鍵
    input_k.send_keys(Keys.ENTER)
    get_goods_info(bro)


except Exception as e:
    print(e)

finally:
    bro.close()

13 自動登入12306

from selenium import webdriver
import time
# pip install pillow
from PIL import Image
# 引入超級鷹
from chaojiying import Chaojiying_Client

from selenium.webdriver import ActionChains

bro = webdriver.Chrome(executable_path='./chromedriver.exe')
bro.implicitly_wait(10)
try:
    bro.get('https://kyfw.12306.cn/otn/resources/login.html')
    bro.maximize_window()  # 視窗最大化，全屏
    button_z = bro.find_element_by_css_selector('.login-hd-account a')
    button_z.click()
    time.sleep(2)
    # 擷取整個螢幕
    bro.save_screenshot('./main.png')
    # 驗證碼的位置和大小
    img_t = bro.find_element_by_id('J-loginImg')
    print(img_t.size)
    print(img_t.location)

    size = img_t.size
    location = img_t.location

    img_tu = (
    int(location['x']), int(location['y']), int(location['x'] + size['width']), int(location['y'] + size['height']))
    # # 摳出驗證碼
    # #開啟
    img = Image.open('./main.png')
    # 摳圖
    fram = img.crop(img_tu)
    # 截出來的小圖
    fram.save('code.png')

    # 呼叫超級鷹破解
    chaojiying = Chaojiying_Client('306334678', 'lqz12345', '903641')  # 使用者中心>>軟體ID 生成一個替換 96001
    im = open('code.png', 'rb').read()  # 本地圖片檔案路徑 來替換 a.jpg 有時WIN系統須要//
    # print(chaojiying.PostPic(im, 9004))

    ## 返回結果如果有多個 260,133|123，233,處理這種格式[[260,133],[123,233]]
    res = chaojiying.PostPic(im, 9004)
    print(res)
    result = res['pic_str']

    all_list = []
    if '|' in result:
        list_1 = result.split('|')
        count_1 = len(list_1)
        for i in range(count_1):
            xy_list = []
            x = int(list_1[i].split(',')[0])
            y = int(list_1[i].split(',')[1])
            xy_list.append(x)
            xy_list.append(y)
            all_list.append(xy_list)
    else:
        x = int(result.split(',')[0])
        y = int(result.split(',')[1])
        xy_list = []
        xy_list.append(x)
        xy_list.append(y)
        all_list.append(xy_list)
    print(all_list)
    # 用動作鏈，點選圖片
    # [[260,133],[123,233]]
    for a in all_list:
        x = a[0]
        y = a[1]
        ActionChains(bro).move_to_element_with_offset(img_t, x, y).click().perform()
        time.sleep(1)

    username = bro.find_element_by_id('J-userName')
    username.send_keys('306334678')
    password = bro.find_element_by_id('J-password')
    password.send_keys('lqz12345')
    time.sleep(3)
    submit_login = bro.find_element_by_id('J-login')
    submit_login.click()
    time.sleep(3)

    print(bro.get_cookies())
    time.sleep(10)
    bro.get('https://www.12306.cn/index/')
    time.sleep(5)

except Exception as e:
    print(e)
finally:
    bro.close()

14 cookie池

# 如何搭建cookie池
# selenium寫一套(一堆小號)，跑起指令碼，自動登入，手動參與
# 拿到cookie，放到redis中
# django搭建一個服務：127.0.0.0/get,隨機返回一個cookie
# request傳送請求爬資料(selenium拿到的cookie)，cookie失效

15 抓包工具介紹

# 1 瀏覽器除錯模式
# 2 fiddler，charles(自己研究一下)

16 scrapy

16.1 scrapy簡介

# scrapy是通用的網路爬蟲框架,爬蟲界的django

# scrapy的五大元件
    -引擎(EGINE)：引擎負責控制系統所有元件之間的資料流，並在某些動作發生時觸發事件
    -排程器(SCHEDULER)：用來接受引擎發過來的請求, 壓入佇列中, 並在引擎再次請求的時候返回. 可以想像成一個URL的優先順序佇列, 由它來決定下一個要抓取的網址是什麼, 同時去除重複的網址
    -下載器(DOWLOADER)：用於下載網頁內容, 並將網頁內容返回給EGINE，下載器是建立在twisted這個高效的非同步模型上的
    -爬蟲(SPIDERS):開發人員自定義的類，用來解析responses，並且提取items，或者傳送新的請求request
    -專案管道(ITEM PIPLINES):在items被提取後負責處理它們，主要包括清理、驗證、持久化(比如存到資料庫)等操作
        
       
    
# scrapy的兩大中介軟體
    -爬蟲中介軟體：位於EGINE和SPIDERS之間，主要工作是處理SPIDERS的輸入和輸出(用的很少)
    -下載中介軟體：位於引擎和下載器之間，可以加代理，加請求頭，整合selenium

scrapy執行流程，架構圖

16.2 scrapy安裝

# 1 pip3 install scrapy(mac，linux可以正常執行)

# 2 windows執行該命令，可能能直接成功，少部分人成功不了

# 報錯解決方案：
	1、pip3 install wheel 
    # 安裝後，便支援通過wheel檔案安裝軟體，wheel檔案官網：https://www.lfd.uci.edu/~gohlke/pythonlibs
    2、pip3 install lxml
    3、pip3 install pyopenssl
    4、pip3 install pywin32
    5、下載twisted的wheel檔案：http://www.lfd.uci.edu/~gohlke/pythonlibs/#twisted
    6、執行pip3 install 下載目錄\Twisted-17.9.0-cp36-cp36m-win_amd64.whl
    7、pip3 install scrapy
    
    
# 3 驗證安裝成功：命令列輸入scrapy,有反應即安裝完成
	\Python36\Scripts\scrapy.exe  該檔案用於建立專案

16.3 scrapy建立專案，建立爬蟲，執行爬蟲

# 1 建立專案
	-scrapy startproject 專案名
	-scrapy startproject firstscrapy
# 2 建立爬蟲
	-scrapy genspider 爬蟲名 爬蟲地址
    -scrapy genspider chouti dig.chouti.com
    -執行後會在spider資料夾下建立一個py檔案，名字為chouti
# 3 執行爬蟲
	-scrapy crawl chouti   # 輸出日誌
    -scrapy crawl chouti --nolog  # 不輸出日誌
# 4 支援右鍵執行爬蟲
	-在專案路徑下新建一個main.py
    from scrapy.cmdline import execute
	execute(['scrapy','crawl','chouti','--nolog'])

16.4 目錄介紹

firstscrapy  # 專案名字
    firstscrapy # 包
        -spiders # 包含所有的爬蟲檔案
            -baidu.py # 一個個的爬蟲
            -chouti.py
        -middlewares.py # 中介軟體(爬蟲中介軟體，下載中介軟體)
        -pipelines.py   # 持久化相關(操作items.py中類的物件)
        -main.py        # 用於執行爬蟲(自己建立)
        -items.py       # 寫item類
        -settings.py    # 配置檔案
    scrapy.cfg          # 上線相關

16.5 settings部分引數

1 預設情況，scrapy會遵循爬蟲協議，修改配置檔案引數，不遵循協議，強行爬取。
	ROBOTSTXT_OBEY = False
    
2 設定全域性USER_AGENT
	USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/84.0.4147.105 Safari/537.36'

3 設定日誌等級LOG_LEVEL
	LOG_LEVEL = 'ERROR'

16.6 scrapy的資料解析

# xpath選擇：
    -response.xpath('//a[contains(@class,"link-title")]/text()').extract()  # 取文字
    -response.xpath('//a[contains(@class,"link-title")]/@href').extract()  # 取屬性
# css選擇：
    -response.css('.link-title::text').extract()  # 取文字
    -response.css('.link-title::attr(href)').extract_first()  # 取屬性

response.selector.css()
response.selector.xpath()
可簡寫為
response.css()
response.xpath()

#1 //與/
response.xpath('//body/a/')#
response.css('div a::text')

response.xpath('//body/a') #開頭的//代表從整篇文件中尋找,body之後的/代表body的兒子
[]
response.xpath('//body//a') #開頭的//代表從整篇文件中尋找,body之後的//代表body的子子孫孫
[<Selector xpath='//body//a' data='<a href="image1.html">Name: My image 1 <'>, <Selector xpath='//body//a' data='<a href="image2.html">Name: My image 2 <'>, <Selector xpath='//body//a' data='<a href="
image3.html">Name: My image 3 <'>, <Selector xpath='//body//a' data='<a href="image4.html">Name: My image 4 <'>, <Selector xpath='//body//a' data='<a href="image5.html">Name: My image 5 <'>]

#2 text
response.xpath('//body//a/text()')
response.css('body a::text')

#3、extract與extract_first:從selector物件中解出內容
response.xpath('//div/a/text()').extract()
['Name: My image 1 ', 'Name: My image 2 ', 'Name: My image 3 ', 'Name: My image 4 ', 'Name: My image 5 ']
response.css('div a::text').extract()
['Name: My image 1 ', 'Name: My image 2 ', 'Name: My image 3 ', 'Name: My image 4 ', 'Name: My image 5 ']

response.xpath('//div/a/text()').extract_first()
'Name: My image 1 '
response.css('div a::text').extract_first()
'Name: My image 1 '

#4、屬性：xpath的屬性加字首@
response.xpath('//div/a/@href').extract_first()
'image1.html'
response.css('div a::attr(href)').extract_first()
'image1.html'

#4、巢狀查詢
response.xpath('//div').css('a').xpath('@href').extract_first()
'image1.html'

#5、設定預設值
response.xpath('//div[@id="xxx"]').extract_first(default="not found")
'not found'

#4、按照屬性查詢
response.xpath('//div[@id="images"]/a[@href="image3.html"]/text()').extract()
response.css('#images a[@href="image3.html"]/text()').extract()

#5、按照屬性模糊查詢
response.xpath('//a[contains(@href,"image")]/@href').extract()
response.css('a[href*="image"]::attr(href)').extract()

response.xpath('//a[contains(@href,"image")]/img/@src').extract()
response.css('a[href*="imag"] img::attr(src)').extract()

response.xpath('//*[@href="image1.html"]')
response.css('*[href="image1.html"]')

#6、正則表示式
response.xpath('//a/text()').re(r'Name: (.*)')
response.xpath('//a/text()').re_first(r'Name: (.*)')

#7、xpath相對路徑
res=response.xpath('//a[contains(@href,"3")]')[0]
res.xpath('img')
[<Selector xpath='img' data='<img src="image3_thumb.jpg">'>]
res.xpath('./img')
[<Selector xpath='./img' data='<img src="image3_thumb.jpg">'>]
res.xpath('.//img')
[<Selector xpath='.//img' data='<img src="image3_thumb.jpg">'>]
res.xpath('//img') #這就是從頭開始掃描
[<Selector xpath='//img' data='<img src="image1_thumb.jpg">'>, <Selector xpath='//img' data='<img src="image2_thumb.jpg">'>, <Selector xpath='//img' data='<img src="image3_thumb.jpg">'>, <Selector xpa
th='//img' data='<img src="image4_thumb.jpg">'>, <Selector xpath='//img' data='<img src="image5_thumb.jpg">'>]

#8、帶變數的xpath
response.xpath('//div[@id=$xxx]/a/text()',xxx='images').extract_first()
'Name: My image 1 '
response.xpath('//div[count(a)=$yyy]/@id',yyy=5).extract_first() #求有5個a標籤的div的id
'images'

16.7 scrapy的持久化儲存

# 1 方案一：
	parser函式必須返回列表套字典的形式(瞭解)
	執行命令：scrapy crawl 爬蟲名 -o 檔名
    
# 2 方案二：通過pipline，item儲存(mysql，redis，檔案)
	-在Items.py中寫一個類
    -在spider中匯入，例項化，把資料放進去
    	    item['title']=title
            item['url']=url
            item['photo_url']=photo_url
            yield item
            
    -在setting中配置(數字越小，級別越高)
    	ITEM_PIPELINES = {
   		'firstscrapy.pipelines.ChoutiFilePipeline': 300,
		}
    -在pipelines.py中寫ChoutiFilePipeline
    	-open_spider(開始的時候)
        -close_spider(結束的時候)
        -process_item(在這持久化)

# 方案2
# items.py
import scrapy

class ChoutiItem(scrapy.Item):
    title = scrapy.Field()
    url = scrapy.Field()
    photo_url = scrapy.Field()
    
    
    
# pipelines.py
class ChoutiFilePipeline(object):
    def open_spider(self,spider):
        print('開啟檔案')
        self.file = open('chouti.txt','w',encoding='utf-8')
    def process_item(self, item, spider):
        print('111')
        self.file.write(item['title']+'\n')
        self.file.write(item['url']+'\n')
        self.file.write(item['photo_url']+'\n')
        return item
    def close_spider(self,spider):
        print('關閉檔案')
        self.file.close()
        
        
# settings.py
ITEM_PIPELINES = {
   		'firstscrapy.pipelines.ChoutiFilePipeline': 300,
		}

16.8 scrapy命令

#1 檢視幫助
    scrapy -h
    scrapy <command> -h

#2 有兩種命令：其中Project-only必須切到專案資料夾下才能執行，而Global的命令則不需要
    Global commands:
        startproject #建立專案
        genspider    #建立爬蟲程式
        settings     #如果是在專案目錄下，則得到的是該專案的配置
        runspider    #執行一個獨立的python檔案，不必建立專案
        shell        #scrapy shell url地址  在互動式除錯，如選擇器規則正確與否
        fetch        #獨立於程單純地爬取一個頁面，可以拿到請求頭
        view         #下載完畢後直接彈出瀏覽器，以此可以分辨出哪些資料是ajax請求
        version      #scrapy version 檢視scrapy的版本，scrapy version -v檢視scrapy依賴庫的版本
    Project-only commands:
        crawl        #執行爬蟲，必須建立專案才行，確保配置檔案中ROBOTSTXT_OBEY = False
        check        #檢測專案中有無語法錯誤
        list         #列出專案中所包含的爬蟲名
        edit         #編輯器，一般不用
        parse        #scrapy parse url地址 --callback 回撥函式  #以此可以驗證我們的回撥函式是否正確
        bench        #scrapy bentch壓力測試

#3 官網連結
    https://docs.scrapy.org/en/latest/topics/commands.html

17 爬取抽屜新聞

# chouti.py
import scrapy
from scrapy.http.request import Request
from bs4 import BeautifulSoup
from firstscrapy.items import ChoutiItem


class ChoutiSpider(scrapy.Spider):
    name = 'chouti'
    allowed_domains = ['dig.chouti.com']
    start_urls = ['http://dig.chouti.com/']
    
    def parse(self, response):
        div_list=response.xpath('//div[contains(@class,"link-item")]')
        for div in div_list:
            item = ChoutiItem()
            title=div.css('.link-title::text').extract_first()
            url=div.css('.link-title::attr(href)').extract_first()
            photo_url=div.css('.image-scale::attr(src)').extract_first()
            if not photo_url:
                photo_url=''
            item['title']=title
            item['url']=url
            item['photo_url']=photo_url
            yield item
            # 注意要用yield




# items.py
import scrapy
class ChoutiItem(scrapy.Item):
    title = scrapy.Field()
    url = scrapy.Field()
    photo_url = scrapy.Field()

    
    
# pipelines.py
import pymysql

class ChoutiFilePipeline(object):
    def open_spider(self,spider):
        print('開啟檔案')
        self.file=open('chouti.txt','w',encoding='utf-8')
        
    def process_item(self, item, spider):
        self.file.write(item['title']+'\n')
        self.file.write(item['url']+'\n')
        self.file.write(item['photo_url']+'\n')
        return item
    
    def close_spider(self,spider):
        print('關閉檔案')
        self.file.close()


class ChoutiMysqlPipeline(object):
    
    def open_spider(self,spider):
        self.conn=pymysql.connect( host='127.0.0.1', user='root', password="123",
                 database='chouti', port=3306)
        
    def close_spider(self,spider):
        self.conn.close()
        
    def process_item(self, item, spider):
        cursor=self.conn.cursor()
        sql='insert into article (title,url,photo_url)values(%s,%s,%s) '
        cursor.execute(sql,[item['title'],item['url'],item['photo_url']])
        self.conn.commit()
        return item

18 自動點贊

from selenium import webdriver
import time

bro = webdriver.Chrome(executable_path=r'chromedriver.exe')
bro.implicitly_wait(5)
bro.get('https://dig.chouti.com/')
bro.maximize_window()
login_show = bro.find_element_by_id('login_btn')
login_show.click()
username = bro.find_element_by_name('phone')
username.send_keys('13212106712')
password = bro.find_element_by_name('password')
password.send_keys('wwh123')
login_button = bro.find_element_by_css_selector('button.login-btn')
login_button.click()
time.sleep(10)
# 可能有驗證碼，手動操作一下


with open('cookie.txt','w',encoding='utf-8') as f:
    f.write(str(bro.get_cookies()))
    # 這個cookie不是一個字典，不能直接給requests使用，需要轉一下
bro.close()



# ===================================================================================
import requests
from bs4 import BeautifulSoup


# 這個cookie不是一個字典，不能直接給requests使用，需要轉一下
with open('cookie.txt', 'rb') as f:
    cookie = f.read()
cookies = eval(cookie)
cookie = {}
for i in cookies:
    cookie[i['name']] = i['value']
headers = {
    'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.97 Safari/537.36',
    'referer': 'https://dig.chouti.com/',

}
res = requests.get('https://dig.chouti.com/', cookies=cookie, headers=headers)
soup = BeautifulSoup(res.text,'lxml')
divs = soup.select('.link-con .link-item')
ll = []
for div in divs:
    id = div.get('data-id')
    ll.append(id)

print(ll)


res = requests.get('https://dig.chouti.com/top/24hr?_=159671243913', cookies=cookie, headers=headers, )
# print(res.json())
for item in res.json()['data']:
    ll.append(item['id'])



res = requests.get('https://dig.chouti.com/top/72hr?_=1596712861433', cookies=cookie, headers=headers, )
for item in res.json()['data']:
    ll.append(item['id'])

res = requests.get('https://dig.chouti.com/top/168hr?_=1596712861434', cookies=cookie, headers=headers, )
for item in res.json()['data']:
    ll.append(item['id'])

print(ll)
# https://dig.chouti.com/link/cancel/vote
# linkId: 29832226
headers['content-length'] = '15'
for id in ll:
    res = requests.post('https://dig.chouti.com/link/vote', cookies=cookie, headers=headers, data={'linkId': id})
    print(res.text)

19 爬取cnblogs全站

# cnblog.py
import scrapy
from scrapy.http import Request
from ..items import CNBlogItem


# 爬取cnblogs文章，把標題連線地址和文章內容儲存到mysql，連續爬取n頁


class CnblogSpider(scrapy.Spider):
    name = 'cnblog'
    allowed_domains = ['www.cnblogs.com']
    start_urls = ['http://www.cnblogs.com/']

    def parse(self, response):
        articles = response.css('#post_list article')
        for article in articles:
            item = CNBlogItem()
            title = article.css('.post-item-title::text').extract_first()
            url = article.css('.post-item-title::attr(href)').extract_first()
            print(title)
            item['title'] = title
            item['url'] = url
            request = Request(url, callback=self.parse_content)
            # 需要先爬取文章內容，為了將文章存入item，需要將item傳遞
            request.meta['item'] = item
            # 爬完後回撥到parse_content繼續執行程式碼
            yield request
        # 當頁所有文章爬完後，獲取下一頁的url，繼續請求，回撥parse繼續執行程式碼
        next_page = response.css('.pager a:last-child::attr(href)').extract_first()
        next_url = 'http://www.cnblogs.com' + next_page
        yield Request(next_url, callback=self.parse)

    def parse_content(self, response):
        item = response.meta.get('item')
        article = response.css('#topics').extract_first()
        item['content'] = article
        # print(item)
        return item

        pass
# ====================================================================================
class CNBlogItem(scrapy.Item):
    title = scrapy.Field()
    url = scrapy.Field()
    content = scrapy.Field()

20 scrapy的請求傳參

# 把要傳遞的資料放到meta中
yield Request(url,meta={'item':item})

# 在response物件中取出來
item=response.meta.get('item')

21 提升scrapy爬取資料效率

- 在配置檔案中進行相關的配置即可:(預設還有一套setting)
#1 增加併發：
預設scrapy開啟的併發執行緒為32個，可以適當進行增加。在settings配置檔案中修改CONCURRENT_REQUESTS = 100值為100,併發設定成了為100。

#2 降低日誌級別：
在執行scrapy時，會有大量日誌資訊的輸出，為了減少CPU的使用率。可以設定log輸出資訊為INFO或者ERROR即可。在配置檔案中編寫：LOG_LEVEL = ‘INFO’

# 3 禁止cookie：
如果不是真的需要cookie，則在scrapy爬取資料時可以禁止cookie從而減少CPU的使用率，提升爬取效率。在配置檔案中編寫：COOKIES_ENABLED = False

# 4禁止重試：
對失敗的HTTP進行重新請求(重試)會減慢爬取速度，因此可以禁止重試。在配置檔案中編寫：RETRY_ENABLED = False

# 5 減少下載超時：
如果對一個非常慢的連結進行爬取，減少下載超時可以能讓卡住的連結快速被放棄，從而提升效率。在配置檔案中進行編寫：DOWNLOAD_TIMEOUT = 10 超時時間為10s

22 scrapy的中介軟體

# 爬蟲中介軟體,下載中介軟體都寫在middlewares.py
# 記得配置：配置檔案


# 下載中介軟體
- process_request：返回不同的物件，後續處理不同(加代理...)
    # 1 更換請求頭
    print(type(request.headers))	# Headers物件，繼承了dict
    # from scrapy.http.headers import Headers
    request.headers['User-Agent']='xxx'

    # 2 加cookie ---cookie池
    # 假設已經搭建好cookie池
    request.cookies={'username':'xxxx'}

    # 3 加代理	-----代理池
    print(request.meta)
    request.meta['download_timeout'] = 20
    request.meta["proxy"] = 'http://27.188.62.3:8060'
        
        
        
- process_response：返回不同的物件，後續處理不同


- process_exception

	def process_exception(self, request, exception, spider):
        print('xxxx')
        # request.url='https://www.baidu.com'
        # 不允許直接修改request的url，建立新的request物件
        from scrapy import Request
        request=Request(url='https://www.baidu.com',callback=spider.parser)
        return request

23 在scrapy中的使用selenium

# 注意：使用同一個瀏覽器

# 1 在爬蟲中初始化webdriver物件
from selenium import webdriver

class CnblogSpider(scrapy.Spider):
    name = 'cnblog'
    ...
    bro = webdriver.Chrome(executable_path='chromedriver.exe')
    
    
# 2 在中介軟體中使用(process_request)
spider.bro.get('https://dig.chouti.com/')
response = HtmlResponse(url='https://dig.chouti.com/',
                        body=spider.bro.page_source.encode('utf-8'), 
                        request=request)
return response


# 3 在爬蟲中關閉
def close(self, reason):
    print("我結束了")
    self.bro.close()

24 去重規則原始碼分析

# scrapy模組的預設去重配置為：
DUPEFILTER_CLASS = 'scrapy.dupefilters.RFPDupeFilter'


# scrapy/dupefilters.py
class RFPDupeFilter(BaseDupeFilter):
    """Request Fingerprint duplicates filter"""

    def __init__(self, path=None, debug=False):
        self.fingerprints = set()		# 使用集合去重
        
        
    def request_seen(self, request):
        fp = self.request_fingerprint(request)
        # fp是指紋，即使 查詢引數 順序不同也能識別
        # http://www.example.com/query?id=111&cat=222
        # http://www.example.com/query?cat=222&id=111
        # 內部使用sha1加密處理(hash)添加了請求方式，請求體等
        if fp in self.fingerprints:		# 如果已存在就返回True
            return True
        self.fingerprints.add(fp)	# 不存在則新增入集合
        if self.file:
            self.file.write(fp + '\n')

25 分散式爬蟲(scrapy-redis)

# 1 pip3 install scrapy-redis
# 2 爬蟲原來繼承Spider，現在需要繼承RedisSpider
# 3 不能寫start_urls = ['https:/www.cnblogs.com/']
# 4 需要寫redis_key = 'myspider:start_urls'
# 5 setting中配置：
    # redis的連線
    REDIS_HOST = 'localhost'                            # 主機名
    REDIS_PORT = 6379                                   # 埠
        # 使用scrapy-redis的去重
    DUPEFILTER_CLASS = "scrapy_redis.dupefilter.RFPDupeFilter"
    # 使用scrapy-redis的Scheduler
    # 分散式爬蟲的配置
    SCHEDULER = "scrapy_redis.scheduler.Scheduler"
    # 持久化的可以配置，也可以不配置
    ITEM_PIPELINES = {
       'scrapy_redis.pipelines.RedisPipeline': 299
    }


# 6 去redis中以myspider:start_urls為key，插入一個起始地址
	lpush myspider:start_urls https://www.cnblogs.com/

26 破解知乎登陸(js逆向和解密)

client_id=c3cef7c66a1843f8b3a9e6a1e3160e20&
grant_type=password&
timestamp=1596702006088&
source=com.zhihu.web&
signature=eac4a6c461f9edf86ef33ef950c7b6aa426dbb39&
username=%2B86liuqingzheng&
password=1111111&
captcha=&
lang=en&
utm_source=&
ref_source=other_https%3A%2F%2Fwww.zhihu.com%2Fsignin%3Fnext%3D%252F"


# 破解知乎登陸

import requests    #請求解析庫

import base64							  #base64解密加密庫
from PIL import Image	  			      #圖片處理庫
import hmac								  #加密庫
from hashlib import sha1				  #加密庫
import time
from urllib.parse import urlencode		  #url編碼庫
import execjs							  #python呼叫node.js
from http import cookiejar as cookielib
class Spider():
    def __init__(self):
        self.session = requests.session()
        self.session.cookies = cookielib.LWPCookieJar()    #使cookie可以呼叫save和load方法
        self.login_page_url = 'https://www.zhihu.com/signin?next=%2F'
        self.login_api = 'https://www.zhihu.com/api/v3/oauth/sign_in'
        self.captcha_api = 'https://www.zhihu.com/api/v3/oauth/captcha?lang=en'
        self.headers = {
            'user-agent':'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/57.0.2987.98 Safari/537.36 LBBROWSER',
        }

        self.captcha =''         #存驗證碼
        self.signature = ''	   #存簽名

    # 首次請求獲取cookie
    def get_base_cookie(self):
        self.session.get(url=self.login_page_url, headers=self.headers)

    def deal_captcha(self):
        r = self.session.get(url=self.captcha_api, headers=self.headers)
        r = r.json()
        if r.get('show_captcha'):
            while True:
                r = self.session.put(url=self.captcha_api, headers=self.headers)
                img_base64 = r.json().get('img_base64')
                with open('captcha.png', 'wb') as f:
                    f.write(base64.b64decode(img_base64))
                captcha_img = Image.open('captcha.png')
                captcha_img.show()
                self.captcha = input('輸入驗證碼:')
                r = self.session.post(url=self.captcha_api, data={'input_text': self.captcha},
                                      headers=self.headers)
                if r.json().get('success'):
                    break

    def get_signature(self):
        # 生成加密簽名
        a = hmac.new(b'd1b964811afb40118a12068ff74a12f4', digestmod=sha1)
        a.update(b'password')
        a.update(b'c3cef7c66a1843f8b3a9e6a1e3160e20')
        a.update(b'com.zhihu.web')
        a.update(str(int(time.time() * 1000)).encode('utf-8'))
        self.signature = a.hexdigest()

    def post_login_data(self):
        data = {
            'client_id': 'c3cef7c66a1843f8b3a9e6a1e3160e20',
            'grant_type': 'password',
            'timestamp': str(int(time.time() * 1000)),
            'source': 'com.zhihu.web',
            'signature': self.signature,
            'username': '+8618953675221',
            'password': '',
            'captcha': self.captcha,
            'lang': 'en',
            'utm_source': '',
            'ref_source': 'other_https://www.zhihu.com/signin?next=%2F',
        }

        headers = {
            'x-zse-83': '3_2.0',
            'content-type': 'application/x-www-form-urlencoded',
            'user-agent': 'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/57.0.2987.98 Safari/537.36 LBBROWSER',
        }

        data = urlencode(data)
        with open('zhih.js', 'rt', encoding='utf-8') as f:
            js = execjs.compile(f.read(), cwd='node_modules')
        data = js.call('b', data)

        r = self.session.post(url=self.login_api, headers=headers, data=data)
        print(r.text)
        if r.status_code == 201:
            self.session.cookies.save('mycookie')
            print('登入成功')
        else:
            print('登入失敗')

    def login(self):
        self.get_base_cookie()
        self.deal_captcha()
        self.get_signature()
        self.post_login_data()
if __name__ == '__main__':
    zhihu_spider = Spider()
    zhihu_spider.login()

27 爬蟲的反爬措施總結

1 user-agent
2 referer
3 cookie(cookie池，先訪問一次)
4 頻率限制(代理池，延遲)
5 js加密(扣出來，exjs模組指向)
6 css加密
7 驗證碼(打碼平臺)，半手動
8 圖片懶載入

拓展

寶塔：
	https://github.com/aaPanel/BaoTa/
jumpserver:
    https://github.com/jumpserver/jumpserver/
聊天機器人：
	https://www.cnblogs.com/liuqingzheng/articles/9079192.html
http：
    https://juejin.im/post/6857287743966281736
    https://www.cnblogs.com/PythonLearner/p/13424051.html
web服務端給瀏覽器發信息
# 輪詢和長輪詢
# websocket：channles(django作者寫的)

相關推薦

判斷元素是否有滾動條

因為出現滾動條便意味著元素空間將大於其內容顯示區域，根據這個現象便可以得到判斷是否出現滾動條的規則

基於原生js實現判斷元素是否有指定class名

【注意】以下方法只對class只有一個值的情況下操作 結構部分： <div> <p>1</p>

在vue專案中用html2canvas遇到因為有滾動條截圖不完整問題的解決方法(設定height和windowHeight)

最近有業務需求要將某個頁面生成圖片然後將圖片匯出,然後我選擇用html2canvas進行圖片生成.

CSS——在有滾動條效果的情況下不顯示滾動條的樣式

技術標籤：CSS wxml檔案 <view class="demo"> <view>我是demo</view> <view>我是demo</view>

使div上下左右都有滾動條

使div上下左右都有滾動條 <html> <head> <title>Untitled Document</title>

vue scroll滾動判斷的實現(是否滾動到底部、滾動方向、滾動節流、獲取滾動區域dom元素)

1、是否滾動到底部 isScrollBottom() { // 是否滾動到了底部 this.box = this.$refs.chatListWrapper

CSS元素超出部分滾動，並隱藏滾動條【轉】

利用 css 3 的新特性 -webkit-scrollbar, 但是這種方式不相容 火狐 和 IE <!DOCTYPE html>

滾動條滾動到指定位置，元素執行動畫

建立一個元件，自己起一個名字 <template> <div ref=\"scroll\"> <slot></slot>

使用CSS隱藏元素滾動條

如何隱藏滾動條，同時仍然可以在任何元素上滾動？首先，如果需要隱藏滾動條並在內容溢位時顯示滾動條，只需要設定overflow：auto樣式即可。想要完全隱藏滾動條只需設定overflow：hidden即可，但是這樣一來將導致元素

delphi xe7 判斷listbox滾動條是否到達底部，並載入資料

或者說成，listbox下拉載入資料 方法1：當listbox滾動條完全到達底部； var Form2: TForm2;

監聽滾動條 獲取指定元素到可視區域頂部的距離

技術標籤：js // 監聽滾動條 獲取指定元素到可視區域頂部的距離 $(window).scroll(function(){

解決判斷滾動條觸底時由於scrollTop是小數造成的問題

技術標籤：JavaScriptCSSVue 專案需求如上圖所示，隨著滾動條滑動，錨點改變自己對應的啟用狀態，當滾動條觸底的時候，啟用狀態為最後一個。

Css 偽元素控制進度條_Css控制滾動條_Css ::-webkit-scrollbar整理

一、webkt瀏覽器進度條設定 主要有下面7個屬性 ::-webkit-scrollbar滾動條整體部分，可以設定寬度啥的

js基礎---其餘的樣式相關的屬性/判斷滾動條是否到底

注意：以下樣式都是隻讀的 clientHeight -元素的可見高度，指元素的內容區和內邊距的高度

WPF 判斷一個控制元件的滾動條是否顯示

private bool HasScrollbar(TextBox TextBox){bool HasScrollbar = false;List<Grid> list = FindVisualChild<Grid>(TextBox);foreach (var item in list){if (item.Name == \"Bg\"){if (item.IsVisibl

Vue.js框架：滾動條滾動監聽方法和觸底判斷機制

一、滾動監聽 　　1.監聽方法 　　通過@scroll事件進行監聽，回撥引數為事件 @scroll=\"scrollEvent($event)\"

jQuery 判斷元素是否存在然後按需載入內容的實現程式碼

前端開發的過程中，我們會使用很多 jQuery 外掛，jQuery 外掛使用得多了，會導致網頁開啟速度變慢。而引入的 jQuery 外掛並不是每個頁面都需要的。這時候使用按需載入的方法載入 jQuery 外掛會對前端效能的提升有不少

js滾輪事件 自定義滾動條的實現

本文例項為大家分享了js自定義滾動條的實現的具體程式碼，供大家參考，具體內容如下

JavaScript實現簡易聊天對話方塊(加滾動條)

今天看了幾個JS的視訊，老師佈置了一個編寫一個簡易聊天對話方塊的任務，沒有涉及到Ajax.主要實現了切換頭像模擬兩方的聊天情況，樣式比較簡單，後期可以進行美化。

python tqdm 實現滾動條不上下滾動程式碼(保持一行內滾動)

預設的tqdm的滾動條的寬度很大，所以會使得總長度超過視窗一行所能顯示的量，所以發生上下滾動