遍歷下載網站群————link_crawler
能夠想到的方法有：1.通過網站地圖 2.通過網站的url特點3.像普通用戶一樣追蹤鏈接。
由于1、2兩種方法比較簡單，并且有很大的局限性，所以著重講第三種方法，也是應用面更廣的
方法。
實例：link_crawler('http://example.webscraping.com','/(index|view)')

1.版本1.0

import re
def link_crawler（seed_url）:
    crawl_queue=[seed_url]
    while crawl_queue:
        url=crawl_queue.pop()
        html=download(url)#筆記三中的函數
        crawl_queue.append(get_link(html))
        
def get_link(html):
    webpage_patt=re.compile('<a[^>]+href=["\'](.*?)["\']',re.IGNORECASE)
    return webpage_patt.findall(html.decode())#返回一個包含所以頁面link的列表,由于匹配模式是str類型，而html是bytes類型。所以要把html進行decode（）解碼。--默認為utf-8來解碼

2.按一定規則搜集同類型的頁面，版本2.0

import re
def link_crawler（seed_url,link_res）:
    crawl_queue=[seed_url]
    while crawl_queue:
        url=crawl_queue.pop()
        html=download(url)
        #加入一個過濾器
        for link in get_link(html):
            if re.match(link_res,link):
                crawl_queue.append(link)
        
def get_link(html):
    webpage_patt=re.compile('<a[^>]+href=["\'](.*?)["\']',re.IGNORECASE)
    return webpage_patt.findall(html.decode())#返回一個包含所以頁面link的列表

3.發現get_link的網站是相對鏈接，并不是絕對鏈接所以要拼接，用urllib.parse

版本3.0

import re
from urllib import parse
def link_crawler（seed_url,link_res）:
    crawl_queue=[seed_url]
    while crawl_queue:
        url=crawl_queue.pop()
        html=download(url)
        #加入一個過濾器
        for link in get_link(html):
            if re.match(link_res,link):
                link=parse.urljoin(seed_url,link)
                crawl_queue.append(link)
        
def get_link(html):
    webpage_patt=re.compile('<a[^>]+href=["\'](.*?)["\']',re.IGNORECASE)
    return webpage_patt.findall(html.decode())#返回一個包含所以頁面link的列表

4.發現有的網站之間相互存在鏈接，為避免重復抓取。

版本4.0：

import re
from urllib import parse
def link_crawler(seed_url,link_res):
    crawl_queue=[seed_url]
    seen=set(crawl_queue)
    '''
    這里的前兩行是初始賦值的作用，后面的循環中
    就不好賦值了，特別是在循環中很難操作set（）
    使其增加
    '''
    while crawl_queue:
        url=crawl_queue.pop()
        html=download(url)
        #加入一個過濾器#在過濾器中看是否重復
        for link in get_link(html):
            if re.match(link_res,link):
                link=parse.urljoin(seed_url,link)
                if link not in seen:#先篩選符合條件的link，再進行篩選是否看過，這個順序能減少工作量。
                    crawl_queue.append(link)
                    seen.add(link)
                    
def get_link(html):
    webpage_patt=re.compile('<a[^>]+href=["\'](.*?)["\']',re.IGNORECASE)
    return webpage_patt.findall(html.decode())#返回一個包含所以頁面link的列表

5.為了防止爬蟲被禁，運用urllib.robotparser模塊分析robots.txt

版本5.0

import re
from urllib import parse
from urllib import robotparser


def link_crawler(seed_url,link_res,User_agent='wswp'):
    crawl_queue=[seed_url]
    seen=set(crawl_queue)
    
    #讀取robots.txt
    rp=robotparser.RobotFileParser()
    rp.set_url('http://example.webscraping.com/robots.txt')
    rp.read()
    '''
    這里的前幾行是初始賦值的作用，后面的循環中
    就不再需要賦值了，特別是在循環中很難操作set（）
    使其增加
    '''
    while crawl_queue:
        url=crawl_queue.pop()
        #檢查該url是否能被禁止爬取
        if rp.can_fetch(User_agent,url):
            html=download(url)
            #加入一個過濾器#在過濾器中看是否重復
            for link in get_link(html):
                if re.match(link_res,link):
                    link=parse.urljoin(seed_url,link)
                    if link not in seen:#先篩選符合條件的link，再進行篩選是否看過，這個順序能減少工作量。
                        crawl_queue.append(link)
                        seen.add(link)
        else:
            print('Blocked by robots.txt',url)
                        
def get_link(html):
    webpage_patt=re.compile('<a[^>]+href=["\'](.*?)["\']',re.IGNORECASE)
    return webpage_patt.findall(html.decode())#返回一個包含所以頁面link的列表

6.下載限速，為了防止爬蟲速度過快，遭到禁封和造成服務器過載的風險。需要在兩次同一主站網站下載之間設置延遲：

這時直接加入程序到link_crawler函數中：
應該實現：1.要能記錄兩次下載時間的功能，計算是否需要延遲，以及延時多久。

版本6.0

import re
from urllib import parse
from urllib import robotparser
import time
def link_crawler(seed_url,link_res,User_agent='wswp'):
    crawl_queue=[seed_url]
    seen=set(crawl_queue)
    
    #讀取robots.txt
    rp=robotparser.RobotFileParser()
    rp.set_url('http://example.webscraping.com/robots.txt')
    rp.read()
    '''
    這里的前幾行是初始賦值的作用，后面的循環中
    就不再需要賦值了，特別是在循環中很難操作set（）
    使其增加
    '''
    b=0
    delay=3
    while crawl_queue:
        url=crawl_queue.pop()
        #檢查該url是否能被禁止爬取
        if rp.can_fetch(User_agent,url):
            #時間管理器
            a=time.time()
            if delay:
                sleeptime=delay-(a-b)
                if sleeptime>0:
                    time.sleep(sleeptime)
            html=download(url)
            b=time.time()
            #加入一個過濾器#在過濾器中看是否重復
            for link in get_link(html):
                if re.match(link_res,link):
                    link=parse.urljoin(seed_url,link)
                    if link not in seen:#先篩選符合條件的link，再進行篩選是否看過，這個順序能減少工作量。
                        crawl_queue.append(link)
                        seen.add(link)
        else:
            print('Blocked by robots.txt',url)

但是，在訪問有外鏈的網站時，比如hao123的網址有百度的鏈接。就不需要暫停。
所以還要實現以下功能：
1.要能記錄兩次下載時間的功能，計算是否需要延遲，以及延時多久。
2.要能記錄不同主站的下載時間?！枰獎摻ㄒ粋€字典來建立對應關系。
eg：hao123，下的網址download完了，可以立刻下載baidu下的網址，但是要隔3秒才能下載hao123下的網址。
版本6.1

import time
import re
from urllib import parse
from urllib import robotparser
def link_crawler(seed_url,link_res,User_agent='wswp'):
    crawl_queue=[seed_url]
    seen=set(crawl_queue)
    #讀取robots.txt
    rp=robotparser.RobotFileParser()
    rp.set_url('http://example.webscraping.com/robots.txt')
    rp.read()
    #時間管理器初始化
    #b=0
    last_time={}
    delay=3
    '''
    這里的前幾行是初始賦值的作用，后面的循環中
    就不再需要賦值了，特別是在循環中很難操作set（）
    使其增加
    '''
    while crawl_queue:
        url=crawl_queue.pop()
        #檢查該url是否能被禁止爬取
        if rp.can_fetch(User_agent,url):
            #時間管理器
            #記錄下載的是哪個網站
            net_loc=urlparse(url).netloc
            #a=time.time()
            if delay:
                #sleeptime=delay-(time.time()-last_time[net_loc])#初始化的原因，一開始是空字典，這么做會出錯。需要用到字典取值的另外的方法：.get（key），key存在返回value。不存在返回None
                if last_time.get(net_loc) is not None:
                    sleeptime=delay-(time.time()-last_time[net_loc])
                    if sleeptime>0:
                        time.sleep(sleeptime)
            html=download(url)
            last_time[net_loc]=time.time()
            #b=time.time()
            #加入一個過濾器#在過濾器中看是否重復
            for link in get_link(html):
                if re.match(link_res,link):
                    link=parse.urljoin(seed_url,link)
                    if link not in seen:#先篩選符合條件的link，再進行篩選是否看過，這個順序能減少工作量。
                        crawl_queue.append(link)
                        seen.add(link)
        else:
            print('Blocked by robots.txt',url)

雖然，至此已經解決了下載限速的問題。但是把這種有特點功能的程序都寫在一起并不好，首先代碼的可讀性降低，其次等要修改時間管理器的時候還要找在什么地方要修改。
為了讓程序有更好的擴展性，可以把它模塊化。在程序設計越來越復雜的時候需要把一定功能的程序抽象為模塊（面向對象的設計），讓程序更加可控。
所以建立一個類，其作用就是時間管理器。
版本6.2

import re
from urllib import parse
from urllib import robotparser

class Timedelay:
    #初始化
    def __init__(self,delay)：
        #設置延遲時間
        self.delay=delay
        #創建記錄主站的字典
        self.domains={}
    #創建等待函數，同時還要實現記錄走后一次訪問時間
    def wait(self,url):
        netloc=urlparse(url).netloc
        last_time=self.domains.get(netloc)
        if self.delay and last_time:
            sleeptime=self.delay-(time.time()-last_time)
            if sleeptime>0:
                time.sleep(sleeptime)
        #每次暫停后，或者沒暫停都重置最后一次訪問時間
        self.domains[netloc]=time.time()
        
def link_crawler(seed_url,link_res,User_agent='wswp',delay=None,proxy=None):
    crawl_queue=[seed_url]
    seen=set(crawl_queue)
    
    #讀取robots.txt
    rp=robotparser.RobotFileParser()
    rp.set_url('http://example.webscraping.com/robots.txt')
    rp.read()
    timedelay=Timedelay(delay)#同樣是初始化
    '''
    這里的前幾行是初始賦值的作用，后面的循環中
    就不再需要賦值了，特別是在循環中很難操作set（）
    使其增加
    '''
    while crawl_queue:
        url=crawl_queue.pop()
        #檢查該url是否能被禁止爬取
        if rp.can_fetch(User_agent,url):
            timedelay.wait(url)#暫停，并記下本次主站下載開始時間
            html=download(url,proxy=proxy)
            #加入一個過濾器#在過濾器中看是否重復
            for link in get_link(html):
                if re.match(link_res,link):
                    link=parse.urljoin(seed_url,link)
                    if link not in seen:#先篩選符合條件的link，再進行篩選是否看過，這個順序能減少工作量。
                        crawl_queue.append(link)
                        seen.add(link)
        else:
            print('Blocked by robots.txt',url)  

7.爬蟲陷阱。目前爬蟲會跟蹤以前從沒有訪問過的頁面。但是有的網站動態生成頁面內容，這樣會出現無限多的網頁。這樣爬蟲會無限制鏈接下去。

為了避免爬蟲陷阱，簡單的方法是到達當前頁面經過了多少鏈接，也就是深度。
功能：當達到這個深度的時候就不往隊列里添加鏈接了，修改seen，不僅可以記錄，而且還有對應的深度記錄。改為字典（判別重復的概率低了）

def link_crawler(seed_url,link_res,User_agent='wswp',delay=None,proxy=None,maxdepth=2):
    crawl_queue=[seed_url]
    #seen=set(crawl_queue)
    seen={}
    seen[seed_url]=0
    #讀取robots.txt
    rp=robotparser.RobotFileParser()
    rp.set_url('http://example.webscraping.com/robots.txt')
    rp.read()
    timedelay=Timedelay(delay)#同樣是初始化
    '''
    這里的前幾行是初始賦值的作用，后面的循環中
    就不再需要賦值了，特別是在循環中很難操作set（）
    使其增加
    '''
    while crawl_queue:
        url=crawl_queue.pop()
        #檢查該url是否能被禁止爬取
        if rp.can_fetch(User_agent,url):
            timedelay.wait(url)#暫停，并記下本次主站下載開始時間
            html=download(url,proxy=proxy)
            #加入一個過濾器#在過濾器中看是否重復
            dept=seen[url]
            if dept!=maxdepth:
                for link in get_link(html):
                    if re.match(link_res,link):
                        link=parse.urljoin(seed_url,link)
                        if link not in seen:#先篩選符合條件的link，再進行篩選是否看過，這個順序能減少工作量。
                            crawl_queue.append(link)
                            seen[link]=dept+1
            print(seen)
        else:
            print('Blocked by robots.txt',url)